nx 23.1.0-beta.1 → 23.1.0-beta.3

package/dist/src/command-line/migrate/agentic/prompts/system-prompt.js

@@ -80,9 +80,10 @@ function buildScopeRules(mode) {
     return [
         `<scope_rules>`,
         `- Apply only the changes the migration prompt asks for.`,
-        `- Do not refactor, reformat, or update dependencies beyond what the migration prompt directs.`,
+        `- Do not refactor or update dependencies beyond what the migration prompt directs, and do not reformat files you did not change.`,
+        `- After applying your changes and before writing the handoff, format the files you created or modified so they match the workspace's style. If the workspace uses Prettier, run \`nx format:write\`, which formats your uncommitted changes; if it has no formatter configured, skip this.`,
         `- Do not modify files outside the workspace root.`,
-        `- Do not run other \`nx\` commands that mutate workspace state (\`nx migrate\`, \`nx reset\`, \`nx run-many\`, generators, etc.). Read-only inspection (\`nx show\`, \`nx graph --file\`, reading files) is fine.`,
+        `- Do not run other \`nx\` commands that mutate workspace state (\`nx migrate\`, \`nx reset\`, \`nx run-many\`, generators, etc.), except \`nx format:write\` to format the files you changed. Read-only inspection (\`nx show\`, \`nx graph --file\`, reading files) is fine.`,
         `- If the migration instructions are unclear, internally inconsistent, or conflict with the current workspace state, ask the user for direction (see the handoff contract). Do not guess.`,
         `</scope_rules>`,
     ].join('\n');

package/dist/src/command-line/migrate/migrate.d.ts

@@ -172,6 +172,7 @@ export declare function createFetcher(pmc: PackageManagerCommands): ((pkg: strin
     stats?: MigrateFetchStats;
 };
 export { filterDowngradedUpdates };
+export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
 /**
  * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
  * error code, which npm consistently emits for this class of failure across

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

@@ -6,6 +6,7 @@ exports.resolveCanonicalNxPackage = resolveCanonicalNxPackage;
 exports.resolveInclude = resolveInclude;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.createFetcher = createFetcher;
+exports.generateMigrationsJsonAndUpdatePackageJson = generateMigrationsJsonAndUpdatePackageJson;
 exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.resolveAgenticRunId = resolveAgenticRunId;
 exports.formatSkippedPromptsNextStep = formatSkippedPromptsNextStep;
@@ -1347,6 +1348,7 @@ function readNxVersion(packageJson, root) {
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nx/workspace', root, packageJson) ??
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nrwl/workspace', root, packageJson));
 }
+// Exported for testing the optional-include orchestration seam (see NXC-4590).
 async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     let phase = 'fetch_migrations';
@@ -1417,7 +1419,11 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
         const writableUpdates = (0, update_filters_1.filterDowngradedUpdates)(packageUpdates, (0, catalog_1.resolveCatalogSpecifiers)(originalPackageJson), installedPackageVersions);
         const wrotePackageJson = await updatePackageJson(root, writableUpdates);
         const wroteNxJsonInstallation = await updateInstallationDetails(root, writableUpdates);
-        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, packageUpdates[walkedTargetPackage].version);
+        // Under `--include=optional` the target's own entry is filtered out of
+        // `packageUpdates` (it's a required package), so resolve the version
+        // defensively. Also reused by the completion analytics below.
+        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
+        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, resolvedTargetVersion);
         if (migrations.length > 0) {
             await createMigrationsFile(root, [
                 ...addSplitConfigurationMigrationIfAvailable(from, writableUpdates),
@@ -1429,7 +1435,6 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
             : include === 'optional'
                 ? `- Processed optional dependency updates only (skipped required package updates).`
                 : null;
-        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
         // The param expressions below evaluate before the report function is
         // entered; `safeReport` keeps them inside the analytics boundary so a
         // param-building throw can't surface here and convert an already

package/dist/src/plugins/js/utils/register.d.ts

@@ -35,22 +35,43 @@ export declare function forceRegisterEsmLoader(): void;
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 export declare const NODENEXT_ESM_RESOLVER_SOURCE = "\nconst EXT_FALLBACK = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };\nconst TS_PARENT_RE = /\\.(?:ts|tsx|mts|cts)(?:$|\\?)/;\nexport async function resolve(specifier, context, nextResolve) {\n  try {\n    return await nextResolve(specifier, context);\n  } catch (err) {\n    if (err?.code !== 'ERR_MODULE_NOT_FOUND') throw err;\n    const parent = context.parentURL;\n    if (!parent || !TS_PARENT_RE.test(parent)) throw err;\n    if (!(specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('file:'))) throw err;\n    const m = specifier.match(/(\\.(?:js|mjs|cjs))($|\\?)/);\n    if (!m) throw err;\n    const fallbacks = EXT_FALLBACK[m[1]];\n    if (!fallbacks) throw err;\n    const base = specifier.slice(0, m.index);\n    const suffix = specifier.slice(m.index + m[1].length);\n    for (const ext of fallbacks) {\n      try { return await nextResolve(base + ext + suffix, context); } catch {}\n    }\n    throw err;\n  }\n}\n";
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+export declare function nodeNextEsmResolveHook(specifier: string, context: {
+    parentURL?: string;
+}, nextResolve: (specifier: string, context?: unknown) => {
+    url: string;
+}): {
+    url: string;
+};
+/**
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */

package/dist/src/plugins/js/utils/register.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NODENEXT_ESM_RESOLVER_SOURCE = void 0;
 exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
+exports.nodeNextEsmResolveHook = nodeNextEsmResolveHook;
 exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
 exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
 exports.isNativeStripPreferred = isNativeStripPreferred;
@@ -100,6 +101,10 @@ function ensureEsmLoaderRegistered(opts) {
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 exports.NODENEXT_ESM_RESOLVER_SOURCE = `
@@ -126,20 +131,70 @@ export async function resolve(specifier, context, nextResolve) {
   }
 }
 `;
+const NODENEXT_EXT_FALLBACK = {
+    '.js': ['.ts', '.tsx'],
+    '.mjs': ['.mts'],
+    '.cjs': ['.cts'],
+};
+const NODENEXT_TS_PARENT_RE = /\.(?:ts|tsx|mts|cts)(?:$|\?)/;
+/**
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+function nodeNextEsmResolveHook(specifier, context, nextResolve) {
+    try {
+        return nextResolve(specifier, context);
+    }
+    catch (err) {
+        if (err?.code !== 'ERR_MODULE_NOT_FOUND')
+            throw err;
+        const parent = context.parentURL;
+        if (!parent || !NODENEXT_TS_PARENT_RE.test(parent))
+            throw err;
+        if (!(specifier.startsWith('./') ||
+            specifier.startsWith('../') ||
+            specifier.startsWith('file:'))) {
+            throw err;
+        }
+        const m = specifier.match(/(\.(?:js|mjs|cjs))($|\?)/);
+        if (!m)
+            throw err;
+        const fallbacks = NODENEXT_EXT_FALLBACK[m[1]];
+        if (!fallbacks)
+            throw err;
+        const base = specifier.slice(0, m.index);
+        const suffix = specifier.slice(m.index + m[1].length);
+        for (const ext of fallbacks) {
+            try {
+                return nextResolve(base + ext + suffix, context);
+            }
+            catch {
+                // try the next fallback
+            }
+        }
+        throw err;
+    }
+}
 let nodeNextEsmResolverRegistered = false;
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */
@@ -148,16 +203,16 @@ function ensureNodeNextEsmResolverRegistered() {
         return;
     nodeNextEsmResolverRegistered = true;
     const module = require('node:module');
-    if (typeof module.register !== 'function')
-        return;
     // Skip when a transpiler was preloaded via `--require`/`--import` (e.g.
     // `--require ts-node/register`, which Nx uses only when it runs from `.ts`
-    // source). `module.register()` spins up a loader-hook worker thread on which
-    // Node re-runs those preloads, resolved relative to the *current* working
-    // directory - and Nx plugin workers `chdir()` into the analyzed workspace
-    // first. If that workspace can't resolve the preloaded module, the loader
-    // worker throws and can leave module resolution in a bad state, so we must
-    // avoid the call entirely; catching it is not a clean recovery.
+    // source). The `module.register()` fallback below spins up a loader-hook
+    // worker thread on which Node re-runs those preloads, resolved relative to
+    // the *current* working directory - and Nx plugin workers `chdir()` into the
+    // analyzed workspace first. If that workspace can't resolve the preloaded
+    // module, the loader worker throws and can leave module resolution in a bad
+    // state, so we must avoid the call entirely; catching it is not a clean
+    // recovery. `module.registerHooks()` runs in-thread with no such worker, but
+    // we keep the skip uniform so resolver coverage doesn't vary by Node version.
     //
     // Consequence: in that from-`.ts`-source invocation a `type: module` plugin
     // using NodeNext `.js` specifiers won't get this resolver (a preloaded
@@ -165,6 +220,20 @@ function ensureNodeNextEsmResolverRegistered() {
     // unaffected - its workers run compiled `.js` with no preload.
     if (isTsTranspilerPreloaded())
         return;
+    // Synchronous in-thread hooks (Node 22.15+ / 23.5+). Preferred because
+    // `module.register()` is deprecated (DEP0205) from Node 25.9+/26+.
+    const registerHooks = module.registerHooks;
+    if (typeof registerHooks === 'function') {
+        try {
+            registerHooks.call(module, { resolve: nodeNextEsmResolveHook });
+        }
+        catch {
+            // Best-effort: leave Node's native handling in place rather than failing.
+        }
+        return;
+    }
+    if (typeof module.register !== 'function')
+        return;
     try {
         module.register('data:text/javascript,' + encodeURIComponent(exports.NODENEXT_ESM_RESOLVER_SOURCE));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.1.0-beta.1",
+  "version": "23.1.0-beta.3",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -172,16 +172,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.1.0-beta.1",
-    "@nx/nx-darwin-x64": "23.1.0-beta.1",
-    "@nx/nx-freebsd-x64": "23.1.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "23.1.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "23.1.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "23.1.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "23.1.0-beta.1",
-    "@nx/nx-linux-x64-musl": "23.1.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "23.1.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "23.1.0-beta.1"
+    "@nx/nx-darwin-arm64": "23.1.0-beta.3",
+    "@nx/nx-darwin-x64": "23.1.0-beta.3",
+    "@nx/nx-freebsd-x64": "23.1.0-beta.3",
+    "@nx/nx-linux-arm-gnueabihf": "23.1.0-beta.3",
+    "@nx/nx-linux-arm64-gnu": "23.1.0-beta.3",
+    "@nx/nx-linux-arm64-musl": "23.1.0-beta.3",
+    "@nx/nx-linux-x64-gnu": "23.1.0-beta.3",
+    "@nx/nx-linux-x64-musl": "23.1.0-beta.3",
+    "@nx/nx-win32-arm64-msvc": "23.1.0-beta.3",
+    "@nx/nx-win32-x64-msvc": "23.1.0-beta.3"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",