@nx/playwright 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.1

package/{index.d.ts → dist/index.d.ts}

@@ -1,4 +1,3 @@
 export { playwrightExecutor, PlaywrightExecutorSchema, } from './src/executors/playwright/playwright.impl';
 export { initGenerator } from './src/generators/init/init';
 export { configurationGenerator } from './src/generators/configuration/configuration';
-//# sourceMappingURL=index.d.ts.map

package/{plugin.d.ts → dist/plugin.d.ts}

@@ -1,2 +1 @@
 export { createNodes, createNodesV2, PlaywrightPluginOptions, } from './src/plugins/plugin';
-//# sourceMappingURL=plugin.d.ts.map

package/{preset.d.ts → dist/preset.d.ts}

@@ -1,2 +1 @@
 export * from './src/utils/preset';
-//# sourceMappingURL=preset.d.ts.map

package/{src → dist/src}/executors/merge-reports/merge-reports.impl.d.ts

@@ -4,4 +4,3 @@ export declare function mergeReportsExecutor(options: Schema, context: ExecutorC
     success: boolean;
 }>;
 export default mergeReportsExecutor;
-//# sourceMappingURL=merge-reports.impl.d.ts.map

package/{src → dist/src}/executors/merge-reports/merge-reports.impl.js

@@ -1,17 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeReportsExecutor = mergeReportsExecutor;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const semver_1 = require("semver");
 const reporters_1 = require("../../utils/reporters");
+const versions_1 = require("../../utils/versions");
 async function mergeReportsExecutor(options, context) {
+    const installed = (0, internal_1.getInstalledPackageVersion)('@playwright/test');
+    if (installed && (0, semver_1.lt)(installed, versions_1.minPlaywrightVersionForBlobReports)) {
+        throw new Error(`The "@nx/playwright:merge-reports" executor requires "@playwright/test" version ${versions_1.minPlaywrightVersionForBlobReports} or greater (the version that introduced the "blob" reporter and the "merge-reports" CLI). You are currently using version ${installed}.`);
+    }
     const { config, expectedSuites } = options;
     const projectRoot = (0, node_path_1.join)(context.root, context.projectsConfigurations.projects[context.projectName].root);
     const configPath = (0, node_path_1.join)(projectRoot, config);
-    const playwrightConfig = await (0, config_utils_1.loadConfigFile)(configPath);
+    const playwrightConfig = await (0, internal_1.loadConfigFile)(configPath);
     const reporterOutputs = (0, reporters_1.getReporterOutputs)(playwrightConfig);
     const blobReporterOutput = reporterOutputs.find(([reporter]) => reporter === 'blob');
     if (!blobReporterOutput) {

package/{src → dist/src}/executors/playwright/playwright.impl.d.ts

@@ -37,4 +37,3 @@ export declare function playwrightExecutor(options: PlaywrightExecutorSchema, co
     success: boolean;
 }>;
 export default playwrightExecutor;
-//# sourceMappingURL=playwright.impl.d.ts.map

package/{src → dist/src}/executors/playwright/playwright.impl.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.playwrightExecutor = playwrightExecutor;
 const devkit_1 = require("@nx/devkit");
 const child_process_1 = require("child_process");
+const deprecation_1 = require("../../utils/deprecation");
 async function playwrightExecutor(options, context) {
+    (0, deprecation_1.warnPlaywrightExecutorDeprecation)();
     const projectRoot = context.projectGraph?.nodes?.[context?.projectName]?.data?.root;
     if (!projectRoot) {
         throw new Error(`Unable to find the Project Root for ${context.projectName}. Is it set in the project.json?`);

package/{src → dist/src}/executors/playwright/schema.json

@@ -3,6 +3,7 @@
   "version": 2,
   "title": "Playwright executor",
   "description": "Run Playwright tests.",
+  "x-deprecated": "The `@nx/playwright:playwright` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/playwright:convert-to-inferred` to migrate to the `@nx/playwright/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.",
   "type": "object",
   "properties": {
     "browser": {

package/{src → dist/src}/generators/configuration/configuration.d.ts

@@ -3,4 +3,3 @@ import type { ConfigurationGeneratorSchema } from './schema';
 export declare function configurationGenerator(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
 export declare function configurationGeneratorInternal(tree: Tree, rawOptions: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
 export default configurationGenerator;
-//# sourceMappingURL=configuration.d.ts.map

package/{src → dist/src}/generators/configuration/configuration.js

@@ -3,24 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGenerator = configurationGenerator;
 exports.configurationGeneratorInternal = configurationGeneratorInternal;
 const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
-const prompt_1 = require("@nx/devkit/src/generators/prompt");
 const js_1 = require("@nx/js");
-const generator_prompts_1 = require("@nx/js/src/utils/generator-prompts");
-const package_manager_workspaces_1 = require("@nx/js/src/utils/package-manager-workspaces");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_2 = require("@nx/js/internal");
+const deprecation_1 = require("../../utils/deprecation");
 const child_process_1 = require("child_process");
 const path = tslib_1.__importStar(require("path"));
 const add_linter_1 = require("../../utils/add-linter");
+const assert_supported_playwright_version_1 = require("../../utils/assert-supported-playwright-version");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
-const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
+const internal_3 = require("@nx/eslint/internal");
 function configurationGenerator(tree, options) {
     return configurationGeneratorInternal(tree, { addPlugin: false, ...options });
 }
 async function configurationGeneratorInternal(tree, rawOptions) {
+    (0, assert_supported_playwright_version_1.assertSupportedPlaywrightVersion)(tree);
     const options = await normalizeOptions(tree, rawOptions);
     const tasks = [];
     tasks.push(await (0, init_1.initGenerator)(tree, {
@@ -30,14 +29,25 @@ async function configurationGeneratorInternal(tree, rawOptions) {
     }));
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const offsetFromProjectRoot = (0, devkit_1.offsetFromRoot)(projectConfig.root);
+    const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)(tree);
+    // Always emit `playwright.config.mts`. Node forces `.mts` to ESM
+    // regardless of workspace `type`, so Playwright's runtime routes it
+    // through the ESM loader (`requireOrImport` -> dynamic `import()`),
+    // bypassing the pirates CJS-compile path that breaks ESM-shape `.ts`
+    // configs. Nx's native TS strip loads `.mts` directly via `loadTsFile`.
+    // Playwright's configLoader auto-discovers `.mts` (extension list at
+    // configLoader.js:313 is `.ts/.js/.mts/.mjs/.cts/.cjs`).
     (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'files'), projectConfig.root, {
         offsetFromRoot: offsetFromProjectRoot,
         projectRoot: projectConfig.root,
         webServerCommand: options.webServerCommand ?? null,
         webServerAddress: options.webServerAddress ?? null,
+        isTsSolutionSetup,
         ...options,
     });
-    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    const playwrightConfigFile = options.js
+        ? 'playwright.config.mjs'
+        : 'playwright.config.mts';
     const tsconfigPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json');
     if (tree.exists(tsconfigPath)) {
         if (isTsSolutionSetup) {
@@ -51,7 +61,7 @@ async function configurationGeneratorInternal(tree, rawOptions) {
                 include: [
                     (0, devkit_1.joinPathFragments)(options.directory, '**/*.ts'),
                     (0, devkit_1.joinPathFragments)(options.directory, '**/*.js'),
-                    'playwright.config.ts',
+                    playwrightConfigFile,
                 ],
                 exclude: ['out-tsc', 'test-output'],
             };
@@ -79,7 +89,7 @@ async function configurationGeneratorInternal(tree, rawOptions) {
             include: [
                 '**/*.ts',
                 '**/*.js',
-                'playwright.config.ts',
+                playwrightConfigFile,
                 'src/**/*.spec.ts',
                 'src/**/*.spec.js',
                 'src/**/*.test.ts',
@@ -112,7 +122,7 @@ async function configurationGeneratorInternal(tree, rawOptions) {
     if (isTsSolutionSetup) {
         const packageJsonPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'package.json');
         if (!tree.exists(packageJsonPath)) {
-            const importPath = (0, project_name_and_root_utils_1.resolveImportPath)(tree, projectConfig.name, projectConfig.root);
+            const importPath = (0, internal_1.resolveImportPath)(tree, projectConfig.name, projectConfig.root);
             const packageJson = {
                 name: importPath,
                 version: '0.0.1',
@@ -129,6 +139,7 @@ async function configurationGeneratorInternal(tree, rawOptions) {
         ? p === '@nx/playwright/plugin'
         : p.plugin === '@nx/playwright/plugin');
     if (!hasPlugin) {
+        (0, deprecation_1.warnPlaywrightExecutorGenerating)();
         addE2eTarget(tree, options);
         setupE2ETargetDefaults(tree);
     }
@@ -143,8 +154,8 @@ async function configurationGeneratorInternal(tree, rawOptions) {
         addPlugin: options.addPlugin,
     }));
     if (options.js) {
-        const { ModuleKind } = (0, ensure_typescript_1.ensureTypescript)();
-        (0, devkit_1.toJS)(tree, { extension: '.cjs', module: ModuleKind.CommonJS });
+        const { ModuleKind } = (0, internal_2.ensureTypescript)();
+        (0, devkit_1.toJS)(tree, { extension: '.mjs', module: ModuleKind.ESNext });
     }
     recommendVsCodeExtensions(tree);
     if (!options.skipPackageJson) {
@@ -160,9 +171,9 @@ async function configurationGeneratorInternal(tree, rawOptions) {
         await (0, devkit_1.formatFiles)(tree);
     }
     if (isTsSolutionSetup) {
-        const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(tree, projectConfig.root);
+        const projectPackageManagerWorkspaceState = (0, internal_2.getProjectPackageManagerWorkspaceState)(tree, projectConfig.root);
         if (projectPackageManagerWorkspaceState !== 'included') {
-            tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(projectPackageManagerWorkspaceState, tree.root));
+            tasks.push((0, internal_2.getProjectPackageManagerWorkspaceStateWarningTask)(projectPackageManagerWorkspaceState, tree.root));
         }
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
@@ -172,7 +183,7 @@ async function normalizeOptions(tree, options) {
     const addPlugin = options.addPlugin ??
         (process.env.NX_ADD_PLUGINS !== 'false' &&
             nxJson.useInferencePlugins !== false);
-    const linter = await (0, generator_prompts_1.normalizeLinterOption)(tree, options.linter);
+    const linter = await (0, internal_2.normalizeLinterOption)(tree, options.linter);
     if (!options.webServerCommand || !options.webServerAddress) {
         const { webServerCommand, webServerAddress } = await promptForMissingServeData(options.project);
         options.webServerCommand = webServerCommand;
@@ -186,7 +197,7 @@ async function normalizeOptions(tree, options) {
     };
 }
 async function promptForMissingServeData(projectName) {
-    const { command, port } = await (0, prompt_1.promptWhenInteractive)([
+    const { command, port } = await (0, internal_1.promptWhenInteractive)([
         {
             type: 'input',
             name: 'command',
@@ -243,15 +254,30 @@ function setupE2ETargetDefaults(tree) {
         return;
     }
     // E2e targets depend on all their project's sources + production sources of dependencies
-    nxJson.targetDefaults ??= {};
     const productionFileSet = !!nxJson.namedInputs?.production;
-    nxJson.targetDefaults.e2e ??= {};
-    nxJson.targetDefaults.e2e.cache ??= true;
-    nxJson.targetDefaults.e2e.inputs ??= [
-        'default',
-        productionFileSet ? '^production' : '^default',
-    ];
-    (0, devkit_1.updateNxJson)(tree, nxJson);
+    // Either a `target: 'e2e'` default or a default keyed on the executor
+    // we're about to scaffold will apply to the new target — consider both
+    // before deciding to add cache/inputs. Target-keyed wins when both are
+    // present.
+    const existingForTarget = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
+        target: 'e2e',
+    });
+    const existingForExecutor = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
+        executor: '@nx/playwright:playwright',
+    });
+    const existingCache = existingForTarget?.cache ?? existingForExecutor?.cache;
+    const existingInputs = existingForTarget?.inputs ?? existingForExecutor?.inputs;
+    const patch = {};
+    if (existingCache === undefined) {
+        patch.cache = true;
+    }
+    if (existingInputs === undefined) {
+        patch.inputs = ['default', productionFileSet ? '^production' : '^default'];
+    }
+    if (Object.keys(patch).length > 0) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, { target: 'e2e', ...patch });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
 }
 function addE2eTarget(tree, options) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
@@ -264,7 +290,9 @@ Rename or remove the existing e2e target.`);
         executor: '@nx/playwright:playwright',
         outputs: [`{workspaceRoot}/dist/.playwright/${projectConfig.root}`],
         options: {
-            config: `${projectConfig.root}/playwright.config.${options.js ? 'cjs' : 'ts'}`,
+            // Generator emits `playwright.config.mts` (`.mjs` for `--js`) so the
+            // legacy executor's `--config` flag must point at the same extension.
+            config: `${projectConfig.root}/playwright.config.${options.js ? 'mjs' : 'mts'}`,
         },
     };
     (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
@@ -272,7 +300,7 @@ Rename or remove the existing e2e target.`);
 function ignoreTestOutput(tree, options) {
     // Make sure playwright outputs are not linted.
     if (options.linter === 'eslint') {
-        (0, eslint_file_1.addIgnoresToLintConfig)(tree, '', ['**/test-output']);
+        (0, internal_3.addIgnoresToLintConfig)(tree, '', ['**/test-output']);
     }
     // Handle gitignore
     if (!tree.exists('.gitignore')) {

package/{src/generators/configuration/files/playwright.config.ts.template → dist/src/generators/configuration/files/playwright.config.mts.template}

@@ -9,13 +9,20 @@ const baseURL = process.env['BASE_URL'] || '<% if(webServerAddress) {%><%= webSe
  * Read environment variables from file.
  * https://github.com/motdotla/dotenv
  */
-// require('dotenv').config();
+// import 'dotenv/config';
 
 /**
  * See https://playwright.dev/docs/test-configuration.
+ *
+ * Generated as a .mts file so Node forces ESM regardless of workspace
+ * `type`. Playwright routes `.mts` through its ESM loader (dynamic import,
+ * bypassing the pirates CJS-compile path), and Nx's native TS strip loads
+ * `.mts` directly. Playwright's configLoader auto-discovers
+ * `playwright.config.mts` via its extension list
+ * (.ts/.js/.mts/.mjs/.cts/.cjs).
  */
 export default defineConfig({
-  ...nxE2EPreset(__filename, { testDir: './<%= directory %>' }),
+  ...nxE2EPreset(import.meta.dirname, { testDir: './<%= directory %>' }),
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     baseURL,
@@ -50,7 +57,7 @@ export default defineConfig({
       name: "webkit",
       use: { ...devices["Desktop Safari"] },
     },
-    
+
     // Uncomment for mobile browsers support
     /* {
       name: 'Mobile Chrome',

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -6,4 +6,3 @@ interface Schema {
 }
 export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
 export default convertToInferred;
-//# sourceMappingURL=convert-to-inferred.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToInferred = convertToInferred;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const plugin_1 = require("../../plugins/plugin");
-const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const assert_supported_playwright_version_1 = require("../../utils/assert-supported-playwright-version");
 async function convertToInferred(tree, options) {
+    (0, assert_supported_playwright_version_1.assertSupportedPlaywrightVersion)(tree);
     const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
-    const migratedProjects = await (0, executor_to_plugin_migrator_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/playwright/plugin', plugin_1.createNodesV2, { targetName: 'e2e', ciTargetName: 'e2e-ci' }, [
+    const migratedProjects = await (0, internal_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/playwright/plugin', plugin_1.createNodesV2, { targetName: 'e2e', ciTargetName: 'e2e-ci' }, [
         {
             executors: ['@nx/playwright:playwright'],
             postTargetTransformer,
@@ -14,7 +16,7 @@ async function convertToInferred(tree, options) {
         },
     ], options.project);
     if (migratedProjects.size === 0) {
-        throw new executor_to_plugin_migrator_1.NoTargetsToMigrateError();
+        throw new internal_1.NoTargetsToMigrateError();
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

package/{src → dist/src}/generators/init/init.d.ts

@@ -3,4 +3,3 @@ import { InitGeneratorSchema } from './schema';
 export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
 export declare function initGeneratorInternal(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
 export default initGenerator;
-//# sourceMappingURL=init.d.ts.map

package/{src → dist/src}/generators/init/init.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initGenerator = initGenerator;
 exports.initGeneratorInternal = initGeneratorInternal;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const plugin_1 = require("../../plugins/plugin");
+const assert_supported_playwright_version_1 = require("../../utils/assert-supported-playwright-version");
 const versions_1 = require("../../utils/versions");
 function initGenerator(tree, options) {
     return initGeneratorInternal(tree, { addPlugin: false, ...options });
 }
 async function initGeneratorInternal(tree, options) {
+    (0, assert_supported_playwright_version_1.assertSupportedPlaywrightVersion)(tree);
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
@@ -19,10 +21,10 @@ async function initGeneratorInternal(tree, options) {
         tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
             '@nx/playwright': versions_1.nxVersion,
             '@playwright/test': versions_1.playwrightVersion,
-        }, undefined, options.keepExistingVersions));
+        }, undefined, options.keepExistingVersions ?? true));
     }
     if (options.addPlugin) {
-        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/playwright/plugin', plugin_1.createNodesV2, { targetName: ['e2e', 'playwright:e2e', 'playwright-e2e'] }, options.updatePackageScripts);
+        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/playwright/plugin', plugin_1.createNodesV2, { targetName: ['e2e', 'playwright:e2e', 'playwright-e2e'] }, options.updatePackageScripts);
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

package/{src → dist/src}/generators/init/schema.json

@@ -21,7 +21,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     },
     "updatePackageScripts": {
       "type": "boolean",

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateCreateNodesV2ToCreateNodes;
+exports.rewriteCreateNodesV2Imports = rewriteCreateNodesV2Imports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEPRECATED_NAME = 'createNodesV2';
+const CANONICAL_NAME = 'createNodes';
+// Module specifiers from which `@nx/playwright` publicly exposes `createNodesV2`.
+// A named import or re-export of `createNodesV2` from one of these is rewritten
+// to the canonical `createNodes` export.
+const TARGET_SPECIFIERS = new Set([
+    '@nx/playwright/plugin',
+]);
+let ts;
+async function migrateCreateNodesV2ToCreateNodes(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEPRECATED_NAME)) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Imports(original, TARGET_SPECIFIERS);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Renamed \`${DEPRECATED_NAME}\` imports to \`${CANONICAL_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Imports(source, specifiers) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    let renameLocalUsages = false;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            renameLocalUsages =
+                collectImportRewrite(sourceFile, stmt, specifiers, changes) ||
+                    renameLocalUsages;
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+    }
+    // Renaming a local `createNodesV2` import binding to `createNodes` (a lone
+    // `{ createNodesV2 }`, or one deduped against an existing `createNodes`)
+    // changes the name in scope, so value references to `createNodesV2` in the
+    // file body must be renamed too — otherwise they dangle. Aliased imports and
+    // re-exports keep their local name, so they never trigger this.
+    if (renameLocalUsages) {
+        collectValueUsageRewrites(sourceFile, changes);
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isTargetSpecifier(node, specifiers) {
+    return ts.isStringLiteral(node) && specifiers.has(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return false;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    // Only `import { ... }` carries renameable named bindings. `import x`,
+    // `import * as ns`, and side-effect imports reference the module wholesale
+    // and keep working through the `createNodesV2` runtime alias, so we leave
+    // them be. A mixed `import def, { createNodesV2 }` still has its named
+    // bindings rewritten below — the default binding is untouched.
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return false;
+    }
+    // The local `createNodesV2` binding only disappears when it is imported
+    // without an alias — a lone `{ createNodesV2 }` or one deduped against an
+    // existing `createNodes`. `{ createNodesV2 as x }` keeps the local `x`, so
+    // its in-file usages are unaffected and must not be rewritten.
+    const localBindingRenamed = namedBindings.elements.some((el) => el.name.text === DEPRECATED_NAME &&
+        (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+    return localBindingRenamed;
+}
+function collectExportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!stmt.moduleSpecifier ||
+        !isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    // `export { ... } from '...'` can be rewritten; `export * from '...'` has no
+    // named bindings to rename.
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any
+ * `createNodesV2` specifier to `createNodes`. If renaming would collide with a
+ * `createNodes` that is already present (e.g. `{ createNodes, createNodesV2 }`),
+ * the duplicate is dropped. Returns without recording a change when the binding
+ * list contains no `createNodesV2`.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasDeprecated = elements.some((el) => (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    if (!hasDeprecated) {
+        return;
+    }
+    const seen = new Set();
+    const rendered = [];
+    for (const el of elements) {
+        const text = renderSpecifier(el);
+        if (!seen.has(text)) {
+            seen.add(text);
+            rendered.push(text);
+        }
+    }
+    const start = namedBindings.getStart(sourceFile);
+    changes.push({
+        type: devkit_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => name === DEPRECATED_NAME ? CANONICAL_NAME : name;
+    // `{ name }` — no alias, so the local binding follows the rename.
+    if (!el.propertyName) {
+        return `${typePrefix}${rename(el.name.text)}`;
+    }
+    // `{ propertyName as name }` — only the imported (left) side is renamed; the
+    // local alias is preserved. A now-redundant alias such as
+    // `createNodesV2 as createNodes` collapses to `createNodes`.
+    const canonicalImported = rename(el.propertyName.text);
+    const localName = el.name.text;
+    return canonicalImported === localName
+        ? `${typePrefix}${localName}`
+        : `${typePrefix}${canonicalImported} as ${localName}`;
+}
+/**
+ * Renames value references of `createNodesV2` to `createNodes` in the file
+ * body. Only called once a local `createNodesV2` import binding has actually
+ * been renamed, so these references would otherwise dangle. Occurrences that
+ * are not references to that binding are skipped: the import/export
+ * declarations themselves, property accesses (`x.createNodesV2`), qualified
+ * type names, object-literal keys, and declaration names that shadow the
+ * import. A shorthand property (`{ createNodesV2 }`) is expanded to
+ * `{ createNodesV2: createNodes }` so the property key is preserved. Strings
+ * and comments are never `Identifier` nodes, so they are left alone.
+ */
+function collectValueUsageRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isIdentifier(node) &&
+            node.text === DEPRECATED_NAME &&
+            isRenamableValueUsage(node)) {
+            const start = node.getStart(sourceFile);
+            changes.push({
+                type: devkit_1.ChangeType.Delete,
+                start,
+                length: node.getEnd() - start,
+            }, {
+                type: devkit_1.ChangeType.Insert,
+                index: start,
+                text: ts.isShorthandPropertyAssignment(node.parent)
+                    ? `${DEPRECATED_NAME}: ${CANONICAL_NAME}`
+                    : CANONICAL_NAME,
+            });
+        }
+        node.forEachChild(visit);
+    };
+    sourceFile.forEachChild(visit);
+}
+/**
+ * Whether a `createNodesV2` identifier is a value reference to the renamed
+ * import binding, as opposed to a position that must be left untouched.
+ */
+function isRenamableValueUsage(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    // Import/export bindings — already handled by the declaration rewrite.
+    if (ts.isImportSpecifier(parent) ||
+        ts.isExportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent)) {
+        return false;
+    }
+    // `x.createNodesV2` / `X.createNodesV2` — a member name, not the binding.
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+        return false;
+    }
+    if (ts.isQualifiedName(parent) && parent.right === node) {
+        return false;
+    }
+    // `{ createNodesV2: ... }` — an object-literal key, not the binding.
+    if (ts.isPropertyAssignment(parent) && parent.name === node) {
+        return false;
+    }
+    // A declaration whose name shadows the import (variable, param, etc.).
+    if ((ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent)) &&
+        parent.name === node) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,7 @@
+import { type CreateNodes } from '@nx/devkit';
+export interface PlaywrightPluginOptions {
+    targetName?: string;
+    ciTargetName?: string;
+}
+export declare const createNodes: CreateNodes<PlaywrightPluginOptions>;
+export declare const createNodesV2: CreateNodes<PlaywrightPluginOptions>;