@nx/devkit 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.0

package/{src → dist/src}/utils/add-plugin.d.ts

@@ -1,14 +1,13 @@
-import { CreateNodesV2, ProjectGraph, Tree } from 'nx/src/devkit-exports';
+import { CreateNodes, ProjectGraph, Tree } from 'nx/src/devkit-exports';
 /**
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 
  */
-export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
 /**
  * @deprecated Use `addPlugin` instead
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 
  */
-export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
 export declare function generateCombinations<T>(input: Record<string, T[]>): Record<string, T>[];
-//# sourceMappingURL=add-plugin.d.ts.map

package/{src → dist/src}/utils/add-plugin.js

@@ -14,7 +14,7 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
 async function addPlugin(tree, graph, pluginName, createNodesTuple, options, shouldUpdatePackageJsonScripts) {
     return _addPluginInternal(tree, graph, pluginName, (pluginOptions) => new devkit_internals_1.LoadedNxPlugin({
         name: pluginName,
-        createNodesV2: createNodesTuple,
+        createNodes: createNodesTuple,
     }, {
         plugin: pluginName,
         options: pluginOptions,

package/{src → dist/src}/utils/async-iterable/combine-async-iterables.d.ts

@@ -1,4 +1,3 @@
 export declare function combineAsyncIterables<T = any>(..._iterators: {
     0: AsyncIterable<T>;
 } & AsyncIterable<T>[]): AsyncGenerator<T>;
-//# sourceMappingURL=combine-async-iterables.d.ts.map

package/{src → dist/src}/utils/async-iterable/create-async-iterable.d.ts

@@ -5,4 +5,3 @@ export interface AsyncPushCallbacks<T> {
     registerCleanup?: (cb: () => void | Promise<void>) => void;
 }
 export declare function createAsyncIterable<T = unknown>(listener: (ls: AsyncPushCallbacks<T>) => void): AsyncIterable<T>;
-//# sourceMappingURL=create-async-iterable.d.ts.map

package/{src → dist/src}/utils/async-iterable/index.d.ts

@@ -2,4 +2,3 @@ export * from './create-async-iterable';
 export * from './combine-async-iterables';
 export * from './map-async-iteratable';
 export * from './tap-async-iteratable';
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/utils/async-iterable/map-async-iteratable.d.ts

@@ -1,2 +1 @@
 export declare function mapAsyncIterable<T = any, I = any, O = any>(data: AsyncIterable<T> | AsyncIterableIterator<T>, transform: (input: I, index?: number, data?: AsyncIterable<T> | AsyncIterableIterator<T>) => O): AsyncIterable<O> | AsyncIterableIterator<O>;
-//# sourceMappingURL=map-async-iteratable.d.ts.map

package/{src → dist/src}/utils/async-iterable/tap-async-iteratable.d.ts

@@ -1,2 +1 @@
 export declare function tapAsyncIterable<T = any, I = any, O = any>(data: AsyncIterable<T> | AsyncIterableIterator<T>, fn: (input: I) => void): AsyncIterable<T> | AsyncIterableIterator<T>;
-//# sourceMappingURL=tap-async-iteratable.d.ts.map

package/{src → dist/src}/utils/binary-extensions.d.ts

@@ -1,2 +1 @@
 export declare function isBinaryPath(path: string): boolean;
-//# sourceMappingURL=binary-extensions.d.ts.map

package/dist/src/utils/calculate-hash-for-create-nodes.d.ts

@@ -0,0 +1,8 @@
+import { CreateNodesContext } from 'nx/src/devkit-exports';
+/**
+ * @deprecated Use {@link calculateHashesForCreateNodes} instead, which batches
+ * workspace-context hashing across multiple project roots in a single call.
+ * This will be removed in Nx 24.
+ */
+export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): Promise<string>;
+export declare function calculateHashesForCreateNodes(projectRoots: string[], options: object, context: CreateNodesContext, additionalGlobs?: string[][]): Promise<string[]>;

package/{src → dist/src}/utils/calculate-hash-for-create-nodes.js

@@ -5,6 +5,11 @@ exports.calculateHashesForCreateNodes = calculateHashesForCreateNodes;
 const path_1 = require("path");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
+/**
+ * @deprecated Use {@link calculateHashesForCreateNodes} instead, which batches
+ * workspace-context hashing across multiple project roots in a single call.
+ * This will be removed in Nx 24.
+ */
 async function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
     return (0, devkit_exports_1.hashArray)([
         await (0, devkit_internals_1.hashWithWorkspaceContext)(context.workspaceRoot, [
@@ -15,14 +20,16 @@ async function calculateHashForCreateNodes(projectRoot, options, context, additi
     ]);
 }
 async function calculateHashesForCreateNodes(projectRoots, options, context, additionalGlobs = []) {
+    if (projectRoots.length === 0) {
+        return [];
+    }
     if (additionalGlobs.length &&
         additionalGlobs.length !== projectRoots.length) {
-        throw new Error('If additionalGlobs is provided, it must be the same length as projectRoots');
+        throw new Error(`calculateHashesForCreateNodes: projectRoots.length (${projectRoots.length}) !== additionalGlobs.length (${additionalGlobs.length})`);
     }
-    return (0, devkit_internals_1.hashMultiGlobWithWorkspaceContext)(context.workspaceRoot, projectRoots.map((projectRoot, idx) => [
+    const hashes = await (0, devkit_internals_1.hashMultiGlobWithWorkspaceContext)(context.workspaceRoot, projectRoots.map((projectRoot, idx) => [
         (0, path_1.join)(projectRoot, '**/*'),
         ...(additionalGlobs.length ? additionalGlobs[idx] : []),
-    ])).then((hashes) => {
-        return hashes.map((hash) => (0, devkit_exports_1.hashArray)([hash, (0, devkit_internals_1.hashObject)(options)]));
-    });
+    ]));
+    return hashes.map((hash) => (0, devkit_exports_1.hashArray)([hash, (0, devkit_internals_1.hashObject)(options)]));
 }

package/{src → dist/src}/utils/catalog/index.d.ts

@@ -7,4 +7,3 @@ export { type CatalogManager, getCatalogManager };
  * Returns Map of package name -> catalog name (undefined for default catalog)
  */
 export declare function getCatalogDependenciesFromPackageJson(tree: Tree, packageJsonPath: string, manager: CatalogManager): Map<string, string | undefined>;
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/utils/catalog/manager-factory.d.ts

@@ -3,4 +3,3 @@ import type { CatalogManager } from './manager';
  * Factory function to get the appropriate catalog manager based on the package manager
  */
 export declare function getCatalogManager(workspaceRoot: string): CatalogManager | null;
-//# sourceMappingURL=manager-factory.d.ts.map

package/{src → dist/src}/utils/catalog/manager.d.ts

@@ -38,4 +38,3 @@ export interface CatalogManager {
         catalogName?: string;
     }>): void;
 }
-//# sourceMappingURL=manager.d.ts.map

package/{src → dist/src}/utils/catalog/pnpm-manager.d.ts

@@ -19,4 +19,3 @@ export declare class PnpmCatalogManager implements CatalogManager {
         catalogName?: string;
     }>): void;
 }
-//# sourceMappingURL=pnpm-manager.d.ts.map

package/{src → dist/src}/utils/catalog/types.d.ts

@@ -9,4 +9,3 @@ export interface CatalogDefinitions {
     catalog?: CatalogEntry;
     catalogs?: Record<string, CatalogEntry>;
 }
-//# sourceMappingURL=types.d.ts.map

package/{src → dist/src}/utils/catalog/yarn-manager.d.ts

@@ -19,4 +19,3 @@ export declare class YarnCatalogManager implements CatalogManager {
         catalogName?: string;
     }>): void;
 }
-//# sourceMappingURL=yarn-manager.d.ts.map

package/{src → dist/src}/utils/config-utils.d.ts

@@ -3,4 +3,3 @@ export declare function loadConfigFile<T extends object = any>(configFilePath: s
 export declare function getRootTsConfigPath(): string | null;
 export declare function getRootTsConfigFileName(): string | null;
 export declare function clearRequireCache(): void;
-//# sourceMappingURL=config-utils.d.ts.map

package/{src → dist/src}/utils/config-utils.js

@@ -27,16 +27,71 @@ function isTypeScriptFile(extension) {
 }
 async function loadTypeScriptModule(path, extension, tsconfigFileNames) {
     const tsConfigPath = getTypeScriptConfigPath(path, tsconfigFileNames);
-    if (tsConfigPath) {
-        const unregisterTsProject = (0, devkit_internals_1.registerTsProject)(tsConfigPath);
+    if (!tsConfigPath) {
+        return await loadModuleByExtension(path, extension);
+    }
+    // loadTsFile was added in nx@23. @nx/devkit's peer range supports older
+    // nx majors, so fall back to the legacy registerTsProject + require path
+    // when loadTsFile isn't available on the host nx.
+    if (typeof devkit_internals_1.loadTsFile !== 'function') {
+        const cleanup = (0, devkit_internals_1.registerTsProject)(tsConfigPath);
         try {
             return await loadModuleByExtension(path, extension);
         }
         finally {
-            unregisterTsProject();
+            cleanup();
+        }
+    }
+    // Both .ts and .mts go through loadTsFile first. Node 22.12+ supports
+    // require() of synchronous ESM by default, and loadTsFile's lazy fallback
+    // covers swc/ts-node + tsconfig-paths registration when needed (swc-node
+    // hooks .cts/.mts/.ts via Module._extensions). Async-only ESM modules
+    // (top-level await) throw ERR_REQUIRE_ASYNC_MODULE and fall through to
+    // dynamic import(). ERR_REQUIRE_ESM is the legacy code for the same case
+    // - kept for older Node lines.
+    try {
+        return (0, devkit_internals_1.loadTsFile)(path, tsConfigPath);
+    }
+    catch (e) {
+        if (e?.code !== 'ERR_REQUIRE_ESM' &&
+            e?.code !== 'ERR_REQUIRE_ASYNC_MODULE') {
+            throw e;
+        }
+        // The module must be loaded via dynamic import(). Register
+        // tsconfig-paths first so workspace alias imports resolve, then try a
+        // native dynamic import. Node 22.18+ LTS strips TS types on the ESM
+        // path natively, so pure-ESM TLA configs load without any swc/ts-node
+        // ESM loader. Only escalate to forceRegisterEsmLoader (which throws
+        // when neither @swc-node/register nor ts-node is installed) if the
+        // native attempt hits unsupported TS syntax.
+        const cleanup = (0, devkit_internals_1.registerTsProject)(tsConfigPath);
+        try {
+            return await loadESM(path);
+        }
+        catch (esmErr) {
+            if (esmErr?.code !== 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' ||
+                typeof devkit_internals_1.forceRegisterEsmLoader !== 'function') {
+                throw esmErr;
+            }
+            // Module.register is global and one-shot per process. After this
+            // runs, every subsequent ESM import in the process is routed
+            // through the registered loader, forfeiting Node's native TS
+            // stripping for the dynamic-import path. If neither swc-node nor
+            // ts-node is installed, forceRegisterEsmLoader throws - surface the
+            // original ESM error in that case so the user sees the real
+            // problem, not a misleading "loader missing" message.
+            try {
+                (0, devkit_internals_1.forceRegisterEsmLoader)();
+            }
+            catch {
+                throw esmErr;
+            }
+            return await loadESM(path);
+        }
+        finally {
+            cleanup();
         }
     }
-    return await loadModuleByExtension(path, extension);
 }
 function getTypeScriptConfigPath(path, tsconfigFileNames) {
     const siblingFiles = (0, fs_1.readdirSync)((0, path_1.dirname)(path));

package/{src → dist/src}/utils/convert-nx-executor.d.ts

@@ -5,4 +5,3 @@ import type { Executor } from 'nx/src/devkit-exports';
  * Use this to expose a compatible Angular Builder
  */
 export declare function convertNxExecutor(executor: Executor): any;
-//# sourceMappingURL=convert-nx-executor.d.ts.map

package/{src → dist/src}/utils/find-plugin-for-config-file.d.ts

@@ -1,3 +1,2 @@
 import { type Tree, type PluginConfiguration } from 'nx/src/devkit-exports';
 export declare function findPluginForConfigFile(tree: Tree, pluginName: string, pathToConfigFile: string): Promise<PluginConfiguration>;
-//# sourceMappingURL=find-plugin-for-config-file.d.ts.map

package/dist/src/utils/find-plugin-for-config-file.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPluginForConfigFile = findPluginForConfigFile;
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const minimatch_1 = require("minimatch");
+async function findPluginForConfigFile(tree, pluginName, pathToConfigFile) {
+    const nxJson = (0, devkit_exports_1.readNxJson)(tree);
+    if (!nxJson.plugins) {
+        return;
+    }
+    const pluginRegistrations = nxJson.plugins.filter((p) => (typeof p === 'string' ? p === pluginName : p.plugin === pluginName));
+    for (const plugin of pluginRegistrations) {
+        if (typeof plugin === 'string') {
+            return plugin;
+        }
+        if (!plugin.include && !plugin.exclude) {
+            return plugin;
+        }
+        if (plugin.include || plugin.exclude) {
+            const resolvedPlugin = await import(pluginName);
+            const pluginGlob = resolvedPlugin.createNodes?.[0] ?? resolvedPlugin.createNodesV2?.[0];
+            // The file must be one this plugin actually processes (its path matches
+            // the plugin's createNodes glob) before the registration's include/exclude
+            // filters are applied.
+            const matchingConfigFile = !pluginGlob || (0, minimatch_1.minimatch)(pathToConfigFile, pluginGlob, { dot: true })
+                ? (0, devkit_internals_1.findMatchingConfigFiles)([pathToConfigFile], plugin.include, plugin.exclude)
+                : [];
+            if (matchingConfigFile.length) {
+                return plugin;
+            }
+        }
+    }
+}

package/{src → dist/src}/utils/get-named-inputs.d.ts

@@ -1,9 +1,8 @@
 import type { InputDefinition } from 'nx/src/config/workspace-json-project-json';
-import { CreateNodesContextV2 } from 'nx/src/devkit-exports';
+import { CreateNodesContext } from 'nx/src/devkit-exports';
 /**
  * Get the named inputs available for a directory
  */
-export declare function getNamedInputs(directory: string, context: CreateNodesContextV2): {
+export declare function getNamedInputs(directory: string, context: CreateNodesContext): {
     [inputName: string]: (string | InputDefinition)[];
 };
-//# sourceMappingURL=get-named-inputs.d.ts.map

package/{src → dist/src}/utils/get-workspace-layout.d.ts

@@ -22,4 +22,3 @@ export declare function extractLayoutDirectory(directory?: string): {
     layoutDirectory: string | null;
     projectDirectory?: string;
 };
-//# sourceMappingURL=get-workspace-layout.d.ts.map

package/dist/src/utils/installed-version.d.ts

@@ -0,0 +1,29 @@
+import type { Tree } from 'nx/src/devkit-exports';
+/**
+ * Returns the concrete version of a package as resolved by Node module
+ * resolution from the workspace. Reads the installed package's own
+ * `package.json` — not the workspace's declared range.
+ *
+ * Use this from executor / runtime contexts where node_modules is present.
+ * Generator-time code should use `getDeclaredPackageVersion` instead.
+ *
+ * Returns `null` when the package is not resolvable.
+ */
+export declare function getInstalledPackageVersion(packageName: string): string | null;
+/**
+ * Returns the declared version of a package as read from the workspace's
+ * `package.json`, normalized to a plain semver string (range markers
+ * stripped) suitable for arithmetic comparisons (e.g. `lt(v, '1.37.0')`).
+ *
+ * When the package is missing or declared as `latest`/`next`, falls back to
+ * the cleaned `latestKnownVersion` if provided; otherwise returns `null`.
+ *
+ * Use this from generator-time contexts where node_modules is not assumed
+ * to be present. Executor / runtime code should use
+ * `getInstalledPackageVersion` instead.
+ */
+export declare function getDeclaredPackageVersion(tree: Tree, packageName: string, latestKnownVersion?: string): string | null;
+export declare const NON_SEMVER_DIST_TAGS: readonly ["latest", "next"];
+export type NonSemverDistTag = (typeof NON_SEMVER_DIST_TAGS)[number];
+export declare function isNonSemverDistTag(version: string): version is NonSemverDistTag;
+export declare function normalizeSemver(version: string): string | null;

package/dist/src/utils/installed-version.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_SEMVER_DIST_TAGS = void 0;
+exports.getInstalledPackageVersion = getInstalledPackageVersion;
+exports.getDeclaredPackageVersion = getDeclaredPackageVersion;
+exports.isNonSemverDistTag = isNonSemverDistTag;
+exports.normalizeSemver = normalizeSemver;
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const semver_1 = require("semver");
+const package_json_1 = require("./package-json");
+/**
+ * Returns the concrete version of a package as resolved by Node module
+ * resolution from the workspace. Reads the installed package's own
+ * `package.json` — not the workspace's declared range.
+ *
+ * Use this from executor / runtime contexts where node_modules is present.
+ * Generator-time code should use `getDeclaredPackageVersion` instead.
+ *
+ * Returns `null` when the package is not resolvable.
+ */
+function getInstalledPackageVersion(packageName) {
+    try {
+        const { packageJson } = (0, devkit_internals_1.readModulePackageJson)(packageName);
+        return packageJson.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns the declared version of a package as read from the workspace's
+ * `package.json`, normalized to a plain semver string (range markers
+ * stripped) suitable for arithmetic comparisons (e.g. `lt(v, '1.37.0')`).
+ *
+ * When the package is missing or declared as `latest`/`next`, falls back to
+ * the cleaned `latestKnownVersion` if provided; otherwise returns `null`.
+ *
+ * Use this from generator-time contexts where node_modules is not assumed
+ * to be present. Executor / runtime code should use
+ * `getInstalledPackageVersion` instead.
+ */
+function getDeclaredPackageVersion(tree, packageName, latestKnownVersion) {
+    const declared = (0, package_json_1.getDependencyVersionFromPackageJson)(tree, packageName);
+    if (declared && !isNonSemverDistTag(declared)) {
+        const normalized = normalizeSemver(declared);
+        if (normalized)
+            return normalized;
+    }
+    return latestKnownVersion ? normalizeSemver(latestKnownVersion) : null;
+}
+exports.NON_SEMVER_DIST_TAGS = ['latest', 'next'];
+function isNonSemverDistTag(version) {
+    return exports.NON_SEMVER_DIST_TAGS.includes(version);
+}
+function normalizeSemver(version) {
+    return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version)?.version ?? null;
+}

package/{src → dist/src}/utils/invoke-nx-generator.d.ts

@@ -4,4 +4,3 @@ import { Generator } from 'nx/src/devkit-exports';
  * @param generator The Nx generator to convert to an Angular Devkit Schematic.
  */
 export declare function convertNxGenerator<T = any>(generator: Generator<T>, skipWritingConfigInOldFormat?: boolean): (generatorOptions: T) => (tree: any, context: any) => Promise<any>;
-//# sourceMappingURL=invoke-nx-generator.d.ts.map

package/{src → dist/src}/utils/log-show-project-command.d.ts

@@ -1,2 +1 @@
 export declare function logShowProjectCommand(projectName: string): void;
-//# sourceMappingURL=log-show-project-command.d.ts.map

package/{src → dist/src}/utils/move-dir.d.ts

@@ -3,4 +3,3 @@ import { Tree } from 'nx/src/devkit-exports';
  * Analogous to cp -r oldDir newDir
  */
 export declare function moveFilesToNewDirectory(tree: Tree, oldDir: string, newDir: string): void;
-//# sourceMappingURL=move-dir.d.ts.map

package/{src → dist/src}/utils/names.d.ts

@@ -16,4 +16,3 @@ export declare function names(name: string): {
     constantName: string;
     fileName: string;
 };
-//# sourceMappingURL=names.d.ts.map

package/dist/src/utils/normalize-target-defaults.d.ts

@@ -0,0 +1,32 @@
+import type { TargetDefaultEntry, TargetDefaults, TargetDefaultsRecord } from 'nx/src/devkit-exports';
+/**
+ * Convert an nx.json `targetDefaults` value (either the legacy record shape
+ * or the new array shape) into the normalized array shape.
+ *
+ * Record entries become `{ target: key, ...value }` preserving insertion
+ * order — except executor-shaped keys (e.g. `@nx/vite:test`,
+ * `nx:run-commands`), which become `{ executor: key, ...value }`.
+ *
+ * Returns the array directly when already normalized — callers must not
+ * mutate the result if they want to preserve the underlying nx.json.
+ */
+export declare function normalizeTargetDefaults(raw: TargetDefaults | undefined): TargetDefaultEntry[];
+/**
+ * Project an array of `TargetDefaultEntry` back into the legacy
+ * record shape. The intended caller is a pre-v23 migration that
+ * normalized to array internally but wants to preserve the original
+ * on-disk record shape so it remains valid against pre-v23 nx.json
+ * schemas.
+ *
+ * Each entry's key is its `target` (if set) or `executor`. Entries that
+ * have both keep the locator role on `target` and retain `executor` as
+ * a value field.
+ *
+ * Throws when the input contains entries that the record shape cannot
+ * represent — `projects`/`plugin` filters, two entries that would collapse
+ * to the same key, or entries with neither `target` nor `executor`. The
+ * caller must keep array shape in those cases (or refuse to write the
+ * change). Silently dropping these entries would corrupt nx.json without
+ * the user noticing.
+ */
+export declare function downgradeTargetDefaults(entries: TargetDefaultEntry[]): TargetDefaultsRecord;

package/dist/src/utils/normalize-target-defaults.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTargetDefaults = normalizeTargetDefaults;
+exports.downgradeTargetDefaults = downgradeTargetDefaults;
+// Mirrors `GLOB_CHARACTERS` / `isGlobPattern` from
+// `nx/src/utils/globs.ts`. We can't import from there directly: devkit
+// supports nx +/- 1 major version and that file isn't part of the
+// devkit-exports surface guaranteed across the range. Keeping a local
+// copy that exactly matches the canonical implementation avoids the
+// import while staying behaviorally aligned.
+const GLOB_CHARACTERS = new Set(['*', '|', '{', '}', '(', ')', '[']);
+/**
+ * Convert an nx.json `targetDefaults` value (either the legacy record shape
+ * or the new array shape) into the normalized array shape.
+ *
+ * Record entries become `{ target: key, ...value }` preserving insertion
+ * order — except executor-shaped keys (e.g. `@nx/vite:test`,
+ * `nx:run-commands`), which become `{ executor: key, ...value }`.
+ *
+ * Returns the array directly when already normalized — callers must not
+ * mutate the result if they want to preserve the underlying nx.json.
+ */
+function normalizeTargetDefaults(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw))
+        return raw;
+    const out = [];
+    const record = raw;
+    for (const key of Object.keys(record)) {
+        const value = record[key] ?? {};
+        out.push(isExecutorLikeKey(key)
+            ? { ...value, executor: key }
+            : { ...value, target: key });
+    }
+    return out;
+}
+function isExecutorLikeKey(key) {
+    if (!key.includes(':'))
+        return false;
+    for (const c of key)
+        if (GLOB_CHARACTERS.has(c))
+            return false;
+    return true;
+}
+/**
+ * Project an array of `TargetDefaultEntry` back into the legacy
+ * record shape. The intended caller is a pre-v23 migration that
+ * normalized to array internally but wants to preserve the original
+ * on-disk record shape so it remains valid against pre-v23 nx.json
+ * schemas.
+ *
+ * Each entry's key is its `target` (if set) or `executor`. Entries that
+ * have both keep the locator role on `target` and retain `executor` as
+ * a value field.
+ *
+ * Throws when the input contains entries that the record shape cannot
+ * represent — `projects`/`plugin` filters, two entries that would collapse
+ * to the same key, or entries with neither `target` nor `executor`. The
+ * caller must keep array shape in those cases (or refuse to write the
+ * change). Silently dropping these entries would corrupt nx.json without
+ * the user noticing.
+ */
+function downgradeTargetDefaults(entries) {
+    const out = {};
+    for (const entry of entries) {
+        if (entry.projects !== undefined || entry.plugin !== undefined) {
+            throw new Error(`Cannot downgrade targetDefaults to legacy record shape: entry ${JSON.stringify(entry)} uses a \`projects\`/\`plugin\` filter, which is only supported in the array shape.`);
+        }
+        const { target, executor, projects, plugin, ...rest } = entry;
+        const key = target ?? executor;
+        if (key === undefined) {
+            throw new Error(`Cannot downgrade targetDefaults to legacy record shape: entry ${JSON.stringify(entry)} has neither \`target\` nor \`executor\` to use as the record key.`);
+        }
+        if (Object.prototype.hasOwnProperty.call(out, key)) {
+            throw new Error(`Cannot downgrade targetDefaults to legacy record shape: two entries collapse to the same key \`${key}\`. Keep the array shape so both can coexist.`);
+        }
+        const value = { ...rest };
+        if (target && executor)
+            value.executor = executor;
+        out[key] = value;
+    }
+    return out;
+}

package/{src → dist/src}/utils/offset-from-root.d.ts

@@ -11,4 +11,3 @@
  * @param fullPathToDir - directory path
  */
 export declare function offsetFromRoot(fullPathToDir: string): string;
-//# sourceMappingURL=offset-from-root.d.ts.map

package/{src → dist/src}/utils/package-json.d.ts

@@ -153,4 +153,3 @@ export declare function ensurePackage<T extends any = any>(pkg: string, version:
  * @description The version of Nx used by the workspace. Returns null if no version is found.
  */
 export declare const NX_VERSION: string;
-//# sourceMappingURL=package-json.d.ts.map

package/{src → dist/src}/utils/package-json.js

@@ -456,7 +456,7 @@ function ensurePackage(pkgOrTree, requiredVersionOrPackage, maybeRequiredVersion
     if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== 'false') {
         throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
     }
-    const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion);
+    const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion, (0, devkit_exports_1.detectPackageManager)(devkit_exports_1.workspaceRoot));
     addToNodePath((0, path_1.join)(devkit_exports_1.workspaceRoot, 'node_modules'));
     addToNodePath((0, path_1.join)(tempDir, 'node_modules'));
     // Re-initialize the added paths into require

package/dist/src/utils/replace-project-configuration-with-plugin.d.ts

@@ -0,0 +1,2 @@
+import { CreateNodes, Tree } from 'nx/src/devkit-exports';
+export declare function replaceProjectConfigurationsWithPlugin<T = unknown>(tree: Tree, rootMappings: Map<string, string>, pluginPath: string, createNodes: CreateNodes<T>, pluginOptions: T): Promise<void>;

package/{src → dist/src}/utils/rxjs-for-await.d.ts

@@ -107,4 +107,3 @@ export declare function latestValueFrom<T>(source: Observable<T>): AsyncGenerato
  * @param source the Observable source to await values from
  */
 export declare function nextValueFrom<T>(source: Observable<T>): AsyncGenerator<T, void, void>;
-//# sourceMappingURL=rxjs-for-await.d.ts.map

package/{src → dist/src}/utils/semver.d.ts

@@ -1,4 +1,3 @@
 import { type Tree } from 'nx/src/devkit-exports';
 export declare function checkAndCleanWithSemver(pkgName: string, version: string): string;
 export declare function checkAndCleanWithSemver(tree: Tree, pkgName: string, version: string): string;
-//# sourceMappingURL=semver.d.ts.map

package/{src → dist/src}/utils/string-change.d.ts

@@ -60,4 +60,3 @@ export type StringChange = StringInsertion | StringDeletion;
  * ```
  */
 export declare function applyChangesToString(text: string, changes: StringChange[]): string;
-//# sourceMappingURL=string-change.d.ts.map

package/{src → dist/src}/utils/string-utils.d.ts

@@ -93,4 +93,3 @@ export declare function underscore(str: string): string;
 export declare function capitalize(str: string): string;
 export declare function group(name: string, group: string | undefined): string;
 export declare function featurePath(group: boolean | undefined, flat: boolean | undefined, path: string, name: string): string;
-//# sourceMappingURL=string-utils.d.ts.map

package/dist/src/utils/version-floor.d.ts

@@ -0,0 +1,37 @@
+import type { Tree } from 'nx/src/devkit-exports';
+/**
+ * Throws a standardized error when a package is installed at a version below
+ * a plugin's supported floor.
+ *
+ * Use this at every site where a plugin determines the installed version of
+ * a supported package is below its declared floor, so the message is
+ * consistent across plugins.
+ *
+ * @param packageName Name of the package (e.g. `@angular/core`).
+ * @param installedVersion Version detected in the workspace (e.g. `18.2.0`).
+ * @param floor Lowest version the plugin supports (e.g. `19.0.0`).
+ */
+export declare function throwForUnsupportedVersion(packageName: string, installedVersion: string, floor: string): never;
+/**
+ * Asserts that a package detected in the workspace is at or above the
+ * plugin's supported floor. No-op when the package is not detected
+ * (fresh-install path) or when declared as `latest`/`next`. Throws via
+ * `throwForUnsupportedVersion` (with the original declared range for
+ * clarity) when below floor.
+ *
+ * Use from generator entry points to fail fast on unsupported workspaces
+ * before writing any incompatible config.
+ */
+export declare function assertSupportedPackageVersion(tree: Tree, packageName: string, minSupportedVersion: string): void;
+/**
+ * Asserts that a package installed in the workspace is at or above the
+ * plugin's supported floor. No-op when the package is not resolvable from
+ * `node_modules` (peer not yet satisfied, fresh-install path). Throws via
+ * `throwForUnsupportedVersion` when below floor.
+ *
+ * Use from executor / runtime / preset / library entry points where
+ * node_modules is present and no `Tree` is available. Generator code should
+ * use `assertSupportedPackageVersion` instead, which reads the declared
+ * range from a tree.
+ */
+export declare function assertSupportedInstalledPackageVersion(packageName: string, minSupportedVersion: string): void;