nx 23.1.0 → 23.1.2

package/dist/src/command-line/migrate/migrate.js

@@ -1,24 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangedDepInstaller = exports.isHybridMigration = exports.isPromptOnlyMigration = exports.filterDowngradedUpdates = exports.Migrator = exports.normalizeVersion = void 0;
+exports.isHybridMigration = exports.isPromptOnlyMigration = exports.filterDowngradedUpdates = exports.Migrator = exports.normalizeVersion = void 0;
 exports.formatCommandFailure = formatCommandFailure;
 exports.resolveCanonicalNxPackage = resolveCanonicalNxPackage;
 exports.resolveInclude = resolveInclude;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.createFetcher = createFetcher;
 exports.generateMigrationsJsonAndUpdatePackageJson = generateMigrationsJsonAndUpdatePackageJson;
-exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.resolveAgenticRunId = resolveAgenticRunId;
 exports.formatSkippedPromptsNextStep = formatSkippedPromptsNextStep;
 exports.resolveCreateCommits = resolveCreateCommits;
 exports.resolveShouldRunValidation = resolveShouldRunValidation;
 exports.executeMigrations = executeMigrations;
-exports.runNxOrAngularMigration = runNxOrAngularMigration;
-exports.parseMigrationReturn = parseMigrationReturn;
 exports.migrate = migrate;
 exports.runMigration = runMigration;
-exports.readMigrationCollection = readMigrationCollection;
-exports.getImplementationPath = getImplementationPath;
 exports.resolveMigrationForRun = resolveMigrationForRun;
 exports.resolveDocumentationFileToWorkspacePath = resolveDocumentationFileToWorkspacePath;
 exports.nxCliPath = nxCliPath;
@@ -26,14 +21,12 @@ const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const child_process_1 = require("child_process");
 const safe_prompt_1 = require("./safe-prompt");
-const handle_import_1 = require("../../utils/handle-import");
 const path_1 = require("path");
 const module_1 = require("module");
 const path_2 = require("../../utils/path");
 const semver_1 = require("semver");
 const node_url_1 = require("node:url");
 const util_1 = require("util");
-const tree_1 = require("../../generators/tree");
 const fileutils_1 = require("../../utils/fileutils");
 const tar_1 = require("../../utils/tar");
 const write_formatted_json_file_1 = require("../../utils/write-formatted-json-file");
@@ -55,7 +48,6 @@ const configuration_1 = require("../../config/configuration");
 const child_process_2 = require("../../utils/child-process");
 const client_1 = require("../../daemon/client/client");
 const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
-const project_graph_1 = require("../../project-graph/project-graph");
 const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
 const provenance_1 = require("../../utils/provenance");
 const catalog_1 = require("../../utils/catalog");
@@ -74,6 +66,8 @@ const update_filters_1 = require("./update-filters");
 Object.defineProperty(exports, "filterDowngradedUpdates", { enumerable: true, get: function () { return update_filters_1.filterDowngradedUpdates; } });
 const version_utils_1 = require("./version-utils");
 Object.defineProperty(exports, "normalizeVersion", { enumerable: true, get: function () { return version_utils_1.normalizeVersion; } });
+const execute_migration_1 = require("./execute-migration");
+tslib_1.__exportStar(require("./execute-migration"), exports);
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 function formatCommandFailure(command, error) {
     const normalizeCommandOutput = (output) => {
@@ -116,6 +110,8 @@ class Migrator {
         this.packageUpdates = {};
         this.collectedVersions = {};
         this.promptAnswers = {};
+        this.pendingPackageJsonUpdates = new Map();
+        this.appliedPackageJsonUpdates = new Set();
         if ((opts.include === 'required' || opts.include === 'optional') &&
             !opts.requiredPackages) {
             throw new Error(`Error: 'requiredPackages' is required when 'include' is '${opts.include}'.`);
@@ -143,6 +139,7 @@ class Migrator {
             version: targetVersion,
             addToPackageJson: false,
         });
+        await this.applyPendingPackageJsonUpdates();
         this.applyIncludeFilter();
         const { migrations, promptContents } = await this.createMigrateJson();
         return {
@@ -188,29 +185,66 @@ class Migrator {
         for (const packageToCheck of packagesToCheck) {
             const filteredUpdates = {};
             for (const [packageUpdateKey, packageUpdate] of Object.entries(packageToCheck.updates)) {
-                if (this.areRequirementsMet(packageUpdate.requires) &&
-                    !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
-                    (!this.interactive ||
-                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
-                    const updateEntries = Object.entries(packageUpdate.packages);
-                    // Validate all up front so invalid metadata fails fast, before any
-                    // resolution does I/O.
-                    for (const [name, update] of updateEntries) {
-                        this.validatePackageUpdateVersion(packageToCheck.package, name, update);
-                    }
-                    // Resolve serially: resolution can prompt (pnpm strict cooldown) and
-                    // append to minimumReleaseAgeExclude, so a serial loop avoids
-                    // overlapping prompts and keeps packageUpdates ordering stable.
-                    for (const [name, update] of updateEntries) {
-                        const resolvedUpdate = {
-                            ...update,
-                            version: await this.resolveVersionForCascade(name, update.version),
-                        };
-                        filteredUpdates[name] = resolvedUpdate;
-                        this.packageUpdates[name] = resolvedUpdate;
-                    }
+                Object.assign(filteredUpdates, await this.applyPackageJsonUpdate(packageToCheck.package, packageUpdateKey, packageUpdate));
+            }
+            await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
+        }
+    }
+    async applyPackageJsonUpdate(sourcePackage, packageUpdateKey, packageUpdate) {
+        const appliedKey = JSON.stringify([sourcePackage, packageUpdateKey]);
+        if (this.appliedPackageJsonUpdates.has(appliedKey)) {
+            this.pendingPackageJsonUpdates.delete(appliedKey);
+            return {};
+        }
+        if (!this.areRequirementsMet(packageUpdate.requires) ||
+            this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith)) {
+            this.pendingPackageJsonUpdates.set(appliedKey, {
+                package: sourcePackage,
+                key: packageUpdateKey,
+                update: packageUpdate,
+            });
+            return {};
+        }
+        this.pendingPackageJsonUpdates.delete(appliedKey);
+        if (this.interactive &&
+            !(await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, sourcePackage))) {
+            return {};
+        }
+        this.appliedPackageJsonUpdates.add(appliedKey);
+        const updateEntries = Object.entries(packageUpdate.packages);
+        // Validate all up front so invalid metadata fails fast, before any
+        // resolution does I/O.
+        for (const [name, update] of updateEntries) {
+            this.validatePackageUpdateVersion(sourcePackage, name, update);
+        }
+        const filteredUpdates = {};
+        // Resolve serially: resolution can prompt (pnpm strict cooldown) and append
+        // to minimumReleaseAgeExclude, so a serial loop avoids overlapping prompts
+        // and keeps packageUpdates ordering stable.
+        for (const [name, update] of updateEntries) {
+            const resolvedUpdate = {
+                ...update,
+                version: await this.resolveVersionForCascade(name, update.version),
+            };
+            this.addPackageUpdate(name, resolvedUpdate);
+            filteredUpdates[name] = this.packageUpdates[name];
+        }
+        return filteredUpdates;
+    }
+    async applyPendingPackageJsonUpdates() {
+        while (this.pendingPackageJsonUpdates.size) {
+            let applied = false;
+            const filteredUpdates = {};
+            for (const pending of [...this.pendingPackageJsonUpdates.values()]) {
+                const updates = await this.applyPackageJsonUpdate(pending.package, pending.key, pending.update);
+                if (Object.keys(updates).length) {
+                    applied = true;
+                    Object.assign(filteredUpdates, updates);
                 }
             }
+            if (!applied) {
+                return;
+            }
             await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
         }
     }
@@ -414,7 +448,7 @@ class Migrator {
     }
     addPackageUpdate(name, packageUpdate) {
         if (!this.packageUpdates[name] ||
-            this.gt(packageUpdate.version, this.packageUpdates[name].version)) {
+            !this.lt(packageUpdate.version, this.packageUpdates[name].version)) {
             this.packageUpdates[name] = packageUpdate;
         }
     }
@@ -1051,6 +1085,15 @@ function createFetcher(pmc) {
             migrationsCache[packageName + '-' + packageVersion] = migrations;
         }
         migrations = fetchMigrations(packageName, packageVersion, setCache).then((result) => {
+            // An exact requested version must come back verbatim; a mismatch means
+            // a config surface (registry proxy, override, cooldown gate) silently
+            // substituted another version, which would corrupt the whole plan.
+            if ((0, semver_1.valid)(packageVersion) &&
+                result.version &&
+                result.version !== packageVersion) {
+                throw new Error(`Fetching ${packageName}@${packageVersion} resolved to version ${result.version}. ` +
+                    `Check for registry, override, or minimum-release-age configuration that hides the requested version.`);
+            }
             if (result.schematics) {
                 result.generators = { ...result.schematics, ...result.generators };
                 delete result.schematics;
@@ -1090,8 +1133,30 @@ async function getPackageMigrationsUsingRegistry(packageName, packageVersion) {
     // try to obtain the migrations from the registry directly
     return await downloadPackageMigrationsFromRegistry(packageName, packageVersion, migrationsConfig);
 }
+// Matched exactly: a hostname that merely contains one of these is a different
+// registry. registry.yarnpkg.com is npmjs' CNAME, so it serves the same
+// metadata; the two loopback literals are the spellings of a local registry
+// that the substring below cannot reach, since neither contains "localhost".
+const FULL_METADATA_REGISTRIES = [
+    'registry.npmjs.org',
+    'registry.yarnpkg.com',
+    '127.0.0.1',
+    '[::1]',
+];
+// Matched as substrings, since neither names a single host: a local registry
+// can sit on a subdomain of localhost, and an Artifactory instance is
+// identified only by that word appearing somewhere in its hostname.
+const FULL_METADATA_REGISTRY_MARKERS = [
+    'localhost',
+    'artifactory',
+];
 async function getPackageMigrationsConfigFromRegistry(packageName, packageVersion) {
-    const result = await (0, package_manager_1.packageRegistryView)(packageName, packageVersion, 'nx-migrations ng-update dist --json');
+    const result = await (0, package_manager_1.packageRegistryView)(packageName, packageVersion, [
+        'nx-migrations',
+        'ng-update',
+        'dist',
+        '--json',
+    ]);
     if (!result) {
         return null;
     }
@@ -1099,9 +1164,10 @@ async function getPackageMigrationsConfigFromRegistry(packageName, packageVersio
     if (!json['nx-migrations'] && !json['ng-update']) {
         const registry = new node_url_1.URL('dist' in json ? json.dist.tarball : json.tarball)
             .hostname;
-        // Registries other than npmjs and the local registry may not support full metadata via npm view
-        // so throw error so that fetcher falls back to getting config via install
-        if (!['registry.npmjs.org', 'localhost', 'artifactory'].some((v) => registry.includes(v))) {
+        // Other registries may not support full metadata via npm view; throw to
+        // trigger the install fallback.
+        if (!FULL_METADATA_REGISTRIES.includes(registry) &&
+            !FULL_METADATA_REGISTRY_MARKERS.some((v) => registry.includes(v))) {
             throw new Error(`Getting migration config from registry is not supported from ${registry}`);
         }
     }
@@ -1111,7 +1177,13 @@ async function downloadPackageMigrationsFromRegistry(packageName, packageVersion
     const { dir, cleanup } = (0, package_manager_1.createTempNpmDirectory)();
     let result;
     try {
-        const { tarballPath } = await (0, package_manager_1.packageRegistryPack)(dir, packageName, packageVersion);
+        const { tarballPath } = await (0, package_manager_1.packageRegistryPack)(dir, packageName, packageVersion, 
+        // packageVersion is exact and already resolved through the workspace
+        // package manager's min-release-age policy by the fetcher. In an npm
+        // workspace the pack gate IS that policy, so leave it enforcing; for
+        // other package managers npm's gate is foreign config with no
+        // exclusions and would wrongly re-judge the vetted version.
+        { bypassMinReleaseAge: (0, package_manager_1.detectPackageManager)() !== 'npm' });
         const fullTarballPath = (0, path_1.join)(dir, tarballPath);
         let migrations;
         try {
@@ -1189,7 +1261,7 @@ async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion,
             // as-is by the outer catch instead of being mislabeled as install failures.
             throw new Error(formatCommandFailure(addCommand, e));
         }
-        const { migrations: migrationsFilePath, packageGroup, supportsOptionalMigrations, packageJson, } = readPackageMigrationConfig(packageName, dir);
+        const { migrations: migrationsFilePath, packageGroup, supportsOptionalMigrations, packageJson, } = (0, execute_migration_1.readPackageMigrationConfig)(packageName, dir);
         let migrations = undefined;
         let resolvedPromptFiles;
         if (migrationsFilePath) {
@@ -1216,32 +1288,6 @@ async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion,
     }
     return result;
 }
-function readPackageMigrationConfig(packageName, dir) {
-    const { path: packageJsonPath, packageJson: json } = (0, package_json_1.readModulePackageJson)(packageName, (0, installation_directory_1.getNxRequirePaths)(dir));
-    const config = (0, package_json_1.readNxMigrateConfig)(json);
-    if (!config) {
-        return { packageJson: json, migrations: null, packageGroup: [] };
-    }
-    try {
-        const migrationFile = require.resolve(config.migrations, {
-            paths: [(0, path_1.dirname)(packageJsonPath)],
-        });
-        return {
-            packageJson: json,
-            migrations: migrationFile,
-            packageGroup: config.packageGroup,
-            supportsOptionalMigrations: config.supportsOptionalMigrations,
-        };
-    }
-    catch {
-        return {
-            packageJson: json,
-            migrations: null,
-            packageGroup: config.packageGroup,
-            supportsOptionalMigrations: config.supportsOptionalMigrations,
-        };
-    }
-}
 async function createMigrationsFile(root, migrations) {
     await (0, write_formatted_json_file_1.writeFormattedJsonFile)((0, path_1.join)(root, 'migrations.json'), { migrations });
 }
@@ -1608,118 +1654,6 @@ function showConnectToCloudMessage() {
         return false;
     }
 }
-function runInstall(nxWorkspaceRoot, phase = 'pre-migration') {
-    const cwd = nxWorkspaceRoot ?? process.cwd();
-    const packageManager = (0, package_manager_1.detectPackageManager)(cwd);
-    const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, cwd);
-    const installCommand = `${pmCommands.install} ${pmCommands.ignoreScriptsFlag ?? ''}`;
-    output_1.output.log({
-        title: `Running '${installCommand}' to make sure necessary packages are installed`,
-    });
-    return new Promise((resolve, reject) => {
-        // For npm, pipe stderr so we can detect peer dependency errors while still
-        // mirroring it live to the user's terminal. Other package managers inherit
-        // stderr directly since we don't need to inspect their output.
-        const shouldCaptureStderr = packageManager === 'npm';
-        const child = (0, child_process_1.spawn)(installCommand, {
-            shell: true,
-            stdio: ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
-            windowsHide: true,
-            cwd,
-        });
-        const stderrChunks = [];
-        child.stderr?.on('data', (chunk) => {
-            process.stderr.write(chunk);
-            stderrChunks.push(chunk);
-        });
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            if (shouldCaptureStderr) {
-                const stderr = Buffer.concat(stderrChunks).toString().trim();
-                if (isNpmPeerDepsError(stderr)) {
-                    // Log the remediation guidance here so every caller of `runInstall`
-                    // (CLI migrate, `nx repair`, single-migration runner, etc.) surfaces
-                    // it consistently. Top-level callers catch `NpmPeerDepsInstallError`
-                    // and return a non-zero exit code without re-logging.
-                    logNpmPeerDepsError(phase);
-                    reject(new NpmPeerDepsInstallError());
-                    return;
-                }
-            }
-            reject(new Error(`Command failed: ${installCommand}`));
-        });
-    });
-}
-class NpmPeerDepsInstallError extends Error {
-    constructor() {
-        super('npm install failed due to peer dependency conflicts.');
-        this.name = 'NpmPeerDepsInstallError';
-    }
-}
-/**
- * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
- * error code, which npm consistently emits for this class of failure across
- * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
- * small set of stable phrases in case the code line is missing from the
- * captured output.
- */
-function isNpmPeerDepsError(stderr) {
-    if (/\bERESOLVE\b/.test(stderr)) {
-        return true;
-    }
-    const lowerStderr = stderr.toLowerCase();
-    return (lowerStderr.includes('unable to resolve dependency tree') ||
-        lowerStderr.includes('could not resolve dependency') ||
-        lowerStderr.includes('conflicting peer dependency'));
-}
-function logNpmPeerDepsError(phase) {
-    const peerDepsResolutionSteps = [
-        'Recommended approaches (in order of preference):',
-        '',
-        '1. Use "overrides" in package.json to force compatible versions across the dependency tree.',
-        '   See https://docs.npmjs.com/cli/configuring-npm/package-json#overrides',
-        '2. Persist legacy peer deps resolution in the project ".npmrc":',
-        '   npm config set legacy-peer-deps=true --location=project',
-        '   (bypasses peer dependency resolution; use with caution)',
-        '3. As a last resort, force the installation by running "npm install --force".',
-        '   (does not persist and may produce broken installs)',
-    ];
-    const manualInstallHint = [
-        'If you installed the dependencies manually, pass "--skip-install" to avoid re-installing them:',
-        '   nx migrate --run-migrations --skip-install',
-    ];
-    if (phase === 'pre-migration') {
-        output_1.output.error({
-            title: 'You need to resolve the peer dependency conflicts before the migration can continue',
-            bodyLines: [
-                ...peerDepsResolutionSteps,
-                '',
-                'Once the conflicts are resolved, re-run the migrations:',
-                '   nx migrate --run-migrations',
-                '',
-                ...manualInstallHint,
-            ],
-        });
-    }
-    else {
-        output_1.output.error({
-            title: 'Some migrations have been applied, but installing the updated dependencies failed',
-            bodyLines: [
-                ...peerDepsResolutionSteps,
-                '',
-                'Once the conflicts are resolved, run "npm install" to install the updated dependencies.',
-                'If the migration was interrupted before completing, re-run the remaining migrations:',
-                '   nx migrate --run-migrations',
-                '',
-                ...manualInstallHint,
-            ],
-        });
-    }
-}
 function resolveAgenticRunId(migrations) {
     return (0, semver_1.rsort)(migrations.map((m) => (0, version_utils_1.normalizeVersion)(m.version)))[0];
 }
@@ -1797,7 +1731,7 @@ function resolveShouldRunValidation(args) {
     return args.validate !== false && args.agenticKind === 'enabled';
 }
 async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false, agentic, agenticHasDiffContext = false, shouldRunValidation = false) {
-    const changedDepInstaller = new ChangedDepInstaller(root, shouldSkipInstall);
+    const changedDepInstaller = new execute_migration_1.ChangedDepInstaller(root, shouldSkipInstall);
     const migrationsWithNoChanges = [];
     const sortedMigrations = migrations.sort((a, b) => {
         // Under `--agentic`, hoist the v23 migration that ignores
@@ -1957,7 +1891,7 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
                 }
             }
             else if ((0, migration_shape_1.isHybridMigration)(m)) {
-                const { changes, nextSteps, agentContext, logs, madeChanges } = await runNxOrAngularMigration(root, m, isVerbose, 
+                const { changes, nextSteps, agentContext, logs, madeChanges } = await (0, execute_migration_1.runNxOrAngularMigration)(root, m, isVerbose, 
                 /* captureGeneratorOutput: */ !!agenticRun, resolvedCollection);
                 migrationEmittedNextSteps.push(...nextSteps);
                 if (agenticRun) {
@@ -2021,7 +1955,7 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
                 // Defer commit until validation succeeds; failed validation leaves
                 // changes uncommitted in the working tree for the user to review.
                 const validationRun = agenticRun && shouldRunValidation ? agenticRun : undefined;
-                const { changes, nextSteps, agentContext, logs, madeChanges } = await runNxOrAngularMigration(root, m, isVerbose, 
+                const { changes, nextSteps, agentContext, logs, madeChanges } = await (0, execute_migration_1.runNxOrAngularMigration)(root, m, isVerbose, 
                 /* captureGeneratorOutput: */ !!validationRun, resolvedCollection);
                 migrationEmittedNextSteps.push(...nextSteps);
                 const canRunValidation = !!validationRun && changes.length > 0;
@@ -2098,7 +2032,7 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
             // `nx repair` reuses executeMigrations; only record for migrate runs.
             if ((0, migrate_analytics_1.hasMigrateRunStarted)()) {
                 (0, migrate_analytics_1.reportMigrateRunError)({
-                    code: e instanceof NpmPeerDepsInstallError
+                    code: e instanceof execute_migration_1.NpmPeerDepsInstallError
                         ? 'npm_install'
                         : inAgenticStep
                             ? 'agentic'
@@ -2109,7 +2043,7 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
                     error: e,
                 });
             }
-            if (!(e instanceof NpmPeerDepsInstallError)) {
+            if (!(e instanceof execute_migration_1.NpmPeerDepsInstallError)) {
                 // `withGeneratorOutputCapture` attaches the generator's `console.*`
                 // output as `capturedLogs` (best-effort; may be absent). Surface it
                 // so the user sees what the generator printed before it crashed.
@@ -2163,30 +2097,6 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
         retainedAtSuccess: (0, migrate_output_1.retainedMigrations)(outcomes).map((p) => `${p.package}: ${p.name}`),
     };
 }
-class ChangedDepInstaller {
-    constructor(root, shouldSkipInstall = false) {
-        this.root = root;
-        this.shouldSkipInstall = shouldSkipInstall;
-        this._skippedInstall = false;
-        this.initialDeps = getStringifiedPackageJsonDeps(root);
-    }
-    get skippedInstall() {
-        return this._skippedInstall;
-    }
-    async installDepsIfChanged() {
-        const currentDeps = getStringifiedPackageJsonDeps(this.root);
-        if (this.initialDeps !== currentDeps) {
-            if (this.shouldSkipInstall) {
-                this._skippedInstall = true;
-            }
-            else {
-                await runInstall(this.root, 'post-migration');
-            }
-        }
-        this.initialDeps = currentDeps;
-    }
-}
-exports.ChangedDepInstaller = ChangedDepInstaller;
 function logSkippedPostMigrationInstall(root) {
     const packageManager = (0, package_manager_1.detectPackageManager)(root);
     const installCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager, root).install;
@@ -2195,58 +2105,9 @@ function logSkippedPostMigrationInstall(root) {
         bodyLines: [`Run "${installCommand}" to install the updated dependencies.`],
     });
 }
-async function runNxOrAngularMigration(root, migration, isVerbose, captureGeneratorOutput = false, resolvedCollection) {
-    const { collection, collectionPath } = resolvedCollection ?? readMigrationCollection(migration.package, root);
-    let changes = [];
-    let nextSteps = [];
-    let agentContext = [];
-    let logs = '';
-    // Angular's `ngResult.changes` is synthesized from the schematic's
-    // DryRunEvent stream so Nx and Angular paths can share commit/validation
-    // gating via `changes.length > 0`.
-    let madeChanges = false;
-    logger_1.logger.info(pc.dim('→ Running generator…'));
-    if (!isAngularMigration(collection, migration.name)) {
-        ({ nextSteps, changes, agentContext, logs } = await runNxMigration(root, collectionPath, collection, migration.name, migration.version, captureGeneratorOutput));
-        madeChanges = changes.length > 0;
-        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
-        if (migration.description) {
-            logger_1.logger.info(`  ${migration.description}`);
-        }
-        logger_1.logger.info('');
-        if (!madeChanges) {
-            logger_1.logger.info(`No changes were made\n`);
-            return { changes, nextSteps, agentContext, logs, madeChanges };
-        }
-        logger_1.logger.info('Changes:');
-        (0, tree_1.printChanges)(changes, '  ');
-        logger_1.logger.info('');
-    }
-    else {
-        const ngCliAdapter = await getNgCompatLayer();
-        const migrationProjectGraph = await (0, project_graph_1.createProjectGraphAsync)();
-        const ngResult = await ngCliAdapter.runMigration(root, migration.package, migration.name, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(migrationProjectGraph).projects, isVerbose, migrationProjectGraph);
-        changes = ngResult.changes;
-        madeChanges = ngResult.madeChanges;
-        logs = ngResult.loggingQueue.join('\n');
-        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
-        if (migration.description) {
-            logger_1.logger.info(`  ${migration.description}`);
-        }
-        logger_1.logger.info('');
-        if (!madeChanges) {
-            logger_1.logger.info(`No changes were made\n`);
-            return { changes, nextSteps, agentContext, logs, madeChanges };
-        }
-        logger_1.logger.info('Changes:');
-        ngResult.loggingQueue.forEach((log) => logger_1.logger.info('  ' + log));
-        logger_1.logger.info('');
-    }
-    return { changes, nextSteps, agentContext, logs, madeChanges };
-}
 async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false) {
     if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
-        await runInstall();
+        await (0, execute_migration_1.runInstall)();
     }
     if (!__dirname.startsWith(workspace_root_1.workspaceRoot)) {
         // we are running from a temp installation with nx latest, switch to running
@@ -2419,59 +2280,6 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         appliedCount,
     });
 }
-function getStringifiedPackageJsonDeps(root) {
-    try {
-        const { dependencies, devDependencies } = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
-        return JSON.stringify([dependencies, devDependencies]);
-    }
-    catch {
-        // We don't really care if the .nx/installation property changes,
-        // whenever nxw is invoked it will handle the dep updates.
-        return '';
-    }
-}
-async function runNxMigration(root, collectionPath, collection, name, migrationVersion, captureGeneratorOutput) {
-    const { path: implPath, fnSymbol } = getImplementationPath(collection, collectionPath, name, migrationVersion);
-    const fn = require(implPath)[fnSymbol];
-    const host = new tree_1.FsTree(root, process.env.NX_VERBOSE_LOGGING === 'true', `migration ${collection.name}:${name}`);
-    let result;
-    let logs = '';
-    if (captureGeneratorOutput) {
-        const { withGeneratorOutputCapture } = require('./agentic/capture-generator-output');
-        ({ result, logs } = await withGeneratorOutputCapture(() => fn(host, {})));
-    }
-    else {
-        result = await fn(host, {});
-    }
-    const { nextSteps, agentContext } = parseMigrationReturn(result);
-    host.lock();
-    const changes = host.listChanges();
-    (0, tree_1.flushChanges)(root, changes);
-    return { changes, nextSteps, agentContext, logs };
-}
-function parseMigrationReturn(value) {
-    if (Array.isArray(value)) {
-        return { nextSteps: filterStrings(value), agentContext: [] };
-    }
-    if (value && typeof value === 'object') {
-        const obj = value;
-        return {
-            nextSteps: filterStrings(obj.nextSteps),
-            agentContext: filterStrings(obj.agentContext),
-        };
-    }
-    // Catches `void`, mistakenly-returned generator callbacks, malformed values.
-    return { nextSteps: [], agentContext: [] };
-}
-// Bucket-level tolerance: a single non-string entry shouldn't discard the
-// whole `nextSteps` / `agentContext` array. Migration authors occasionally
-// push `null` / `undefined` / a number into the array; we drop the bad entries
-// and keep the rest so end-of-run guidance isn't silently lost.
-function filterStrings(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((v) => typeof v === 'string');
-}
 async function migrate(root, args, rawArgs) {
     await client_1.daemonClient.stop();
     return (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
@@ -2505,7 +2313,7 @@ async function migrate(root, args, rawArgs) {
                 // The remediation guidance is already logged by `runInstall`; swallow
                 // the error here so `handleErrors` doesn't print a noisy stack after
                 // the friendly output.
-                if (e instanceof NpmPeerDepsInstallError) {
+                if (e instanceof execute_migration_1.NpmPeerDepsInstallError) {
                     (0, migrate_analytics_1.reportMigrateRunError)({ code: 'npm_install', error: e });
                     return 1;
                 }
@@ -2532,6 +2340,10 @@ async function runMigration() {
                 process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
                 delete process.env.npm_config_registry;
             }
+            // Intentionally not runNxSync: `p` is an nx CLI freshly installed into a
+            // temp dir by nxCliPath() (latest, or NX_MIGRATE_CLI_VERSION), so
+            // migrations run with an up-to-date migrate implementation instead of
+            // the workspace's current nx.
             return runOrReturnExitCode(() => (0, child_process_1.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
                 stdio: ['inherit', 'inherit', 'inherit'],
                 windowsHide: true,
@@ -2540,39 +2352,6 @@ async function runMigration() {
         return runLocalMigrate();
     });
 }
-function readMigrationCollection(packageName, root) {
-    const collectionPath = readPackageMigrationConfig(packageName, root).migrations;
-    const collection = (0, fileutils_1.readJsonFile)(collectionPath);
-    collection.name ??= packageName;
-    return {
-        collection,
-        collectionPath,
-    };
-}
-function getImplementationPath(collection, collectionPath, name, migrationVersion) {
-    const g = collection.generators?.[name] || collection.schematics?.[name];
-    if (!g) {
-        throw new MigrationImplementationMissingError(`Unable to determine implementation path for "${collectionPath}:${name}"`, collectionPath, migrationVersion);
-    }
-    const implRelativePathAndMaybeSymbol = g.implementation || g.factory;
-    const [implRelativePath, fnSymbol = 'default'] = implRelativePathAndMaybeSymbol.split('#');
-    let implPath;
-    try {
-        implPath = require.resolve(implRelativePath, {
-            paths: [(0, path_1.dirname)(collectionPath)],
-        });
-    }
-    catch (e) {
-        try {
-            // workaround for a bug in node 12
-            implPath = require.resolve(`${(0, path_1.dirname)(collectionPath)}/${implRelativePath}`);
-        }
-        catch {
-            throw new MigrationImplementationMissingError(`Could not resolve implementation for migration "${name}" from "${collectionPath}"`, collectionPath, migrationVersion ?? g.version);
-        }
-    }
-    return { path: implPath, fnSymbol };
-}
 /**
  * Resolves a migration's collection once and derives everything the run loop
  * needs from that single read: the implementation context (`collection` +
@@ -2591,11 +2370,11 @@ function getImplementationPath(collection, collectionPath, name, migrationVersio
 function resolveMigrationForRun(root, migration, resolveDocumentation) {
     let resolvedCollection;
     if (!(0, migration_shape_1.isPromptOnlyMigration)(migration)) {
-        resolvedCollection = readMigrationCollection(migration.package, root);
+        resolvedCollection = (0, execute_migration_1.readMigrationCollection)(migration.package, root);
     }
     else if (resolveDocumentation && migration.documentation) {
         try {
-            resolvedCollection = readMigrationCollection(migration.package, root);
+            resolvedCollection = (0, execute_migration_1.readMigrationCollection)(migration.package, root);
         }
         catch {
             // Non-fatal: documentation is supplementary; the warning below fires.
@@ -2630,52 +2409,6 @@ function resolveDocumentationFileToWorkspacePath(root, migrationsDir, documentat
     const relativePath = (0, path_1.relative)(root, documentationFile);
     return relativePath.startsWith('..') ? documentationFile : relativePath;
 }
-class MigrationImplementationMissingError extends Error {
-    constructor(baseMessage, collectionPath, migrationVersion) {
-        super(buildMigrationMissingMessage(baseMessage, collectionPath, migrationVersion));
-        this.name = 'MigrationImplementationMissingError';
-    }
-}
-function buildMigrationMissingMessage(baseMessage, collectionPath, migrationVersion) {
-    if (!migrationVersion) {
-        return baseMessage;
-    }
-    try {
-        const packageJsonPath = (0, path_1.join)((0, path_1.dirname)(collectionPath), 'package.json');
-        if (!(0, fs_1.existsSync)(packageJsonPath)) {
-            return baseMessage;
-        }
-        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
-        const installedVersion = packageJson.version;
-        if (installedVersion &&
-            (0, semver_1.lt)((0, version_utils_1.normalizeVersion)(installedVersion), (0, version_utils_1.normalizeVersion)(migrationVersion))) {
-            const packageManager = (0, package_manager_1.detectPackageManager)();
-            const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
-            const overrideFieldName = getOverrideFieldName(packageManager);
-            return (`${baseMessage}\n\n` +
-                `The installed version of "${packageJson.name}" is ${installedVersion}, ` +
-                `but this migration requires version ${migrationVersion}. ` +
-                `This likely means the package version is being held back by an ${overrideFieldName} ` +
-                `in your package.json. ` +
-                `Remove the ${overrideFieldName} and run "${pmc.install}" to install the correct version.`);
-        }
-    }
-    catch {
-        // Fall through to return the base message if we can't read package info
-    }
-    return baseMessage;
-}
-function getOverrideFieldName(packageManager) {
-    switch (packageManager) {
-        case 'pnpm':
-            return '"pnpm.overrides"';
-        case 'yarn':
-            return '"resolutions"';
-        case 'npm':
-        case 'bun':
-            return '"overrides"';
-    }
-}
 async function nxCliPath(nxWorkspaceRoot) {
     const version = process.env.NX_MIGRATE_CLI_VERSION || 'latest';
     const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
@@ -2745,16 +2478,3 @@ function addToNodePath(dir) {
     // Update the env variable.
     process.env.NODE_PATH = paths.join(delimiter);
 }
-function isAngularMigration(collection, name) {
-    return !collection.generators?.[name] && collection.schematics?.[name];
-}
-const getNgCompatLayer = (() => {
-    let _ngCliAdapter;
-    return async function getNgCompatLayer() {
-        if (!_ngCliAdapter) {
-            _ngCliAdapter = await (0, handle_import_1.handleImport)('../../adapter/ngcli-adapter.js', __dirname);
-            require('../../adapter/compat');
-        }
-        return _ngCliAdapter;
-    };
-})();