@depup/nx 23.1.2-depup.1 → 23.2.0-depup.0

package/dist/src/utils/catalog/bun-manager.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunCatalogManager = void 0;
+const manager_1 = require("./manager");
+const bun_manager_utils_1 = require("./bun-manager-utils");
+const BUN_CATALOG_FILENAME = 'package.json';
+/**
+ * Bun-specific catalog manager implementation.
+ *
+ * Bun declares catalogs in the root package.json `catalog`/`catalogs` fields,
+ * either at the top level or nested under the object form of `workspaces`.
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+class BunCatalogManager {
+    constructor() {
+        this.name = 'bun';
+        this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readBunCatalogDefinitions.
+        this.definitionsByRoot = new Map();
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length).trim();
+        // Only an empty/whitespace name selects the default catalog; "default" is
+        // a regular named catalog in bun.
+        const isDefault = !catalogName;
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitionFilePaths() {
+        return [BUN_CATALOG_FILENAME];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        return (0, bun_manager_utils_1.readBunCatalogDefinitions)(BUN_CATALOG_FILENAME, treeOrRoot, this.definitionsByRoot);
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            throw new Error((0, manager_1.formatCatalogError)(`Cannot get Bun catalog definitions. No catalog defined in ${BUN_CATALOG_FILENAME}.`, [
+                `Add a "catalog" or "catalogs" field to ${BUN_CATALOG_FILENAME} in your workspace root`,
+            ]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define a default catalog in ${BUN_CATALOG_FILENAME} under the "catalog" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define the catalog in ${BUN_CATALOG_FILENAME} under the "catalogs" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in ${BUN_CATALOG_FILENAME}`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        (0, bun_manager_utils_1.updateBunCatalogVersionsInFile)(BUN_CATALOG_FILENAME, treeOrRoot, updates);
+    }
+}
+exports.BunCatalogManager = BunCatalogManager;

package/dist/src/utils/catalog/index.d.ts

@@ -4,7 +4,7 @@ import type { CatalogManager } from './manager';
 import { getCatalogManager } from './manager-factory';
 export { type CatalogManager, getCatalogManager };
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

package/dist/src/utils/catalog/index.js

@@ -9,7 +9,7 @@ const workspace_root_1 = require("../workspace-root");
 const manager_factory_1 = require("./manager-factory");
 Object.defineProperty(exports, "getCatalogManager", { enumerable: true, get: function () { return manager_factory_1.getCatalogManager; } });
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

package/dist/src/utils/catalog/manager-factory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCatalogManager = getCatalogManager;
 const package_manager_1 = require("../package-manager");
+const bun_manager_1 = require("./bun-manager");
 const pnpm_manager_1 = require("./pnpm-manager");
 const yarn_manager_1 = require("./yarn-manager");
 /**
@@ -14,6 +15,8 @@ function getCatalogManager(workspaceRoot) {
             return new pnpm_manager_1.PnpmCatalogManager();
         case 'yarn':
             return new yarn_manager_1.YarnCatalogManager();
+        case 'bun':
+            return new bun_manager_1.BunCatalogManager();
         default:
             return null;
     }

package/dist/src/utils/catalog/manager-utils.d.ts

@@ -5,4 +5,11 @@ export declare function updateCatalogVersionsInFile(filename: string, treeOrRoot
     packageName: string;
     version: string;
     catalogName?: string;
-}>): void;
+}>, options?: {
+    /**
+     * Treat "default" as an alias for the `catalog` field and route default
+     * updates through a populated `catalogs.default` (pnpm semantics). When
+     * false, "default" is an ordinary named catalog (yarn semantics).
+     */
+    aliasDefaultCatalog?: boolean;
+}): void;

package/dist/src/utils/catalog/manager-utils.js

@@ -136,7 +136,8 @@ function readCatalogDefinitions(filename, treeOrRoot, cache) {
     }
     return readCatalogConfigFromTree(filename, treeOrRoot);
 }
-function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
+function updateCatalogVersionsInFile(filename, treeOrRoot, updates, options) {
+    const aliasDefaultCatalog = options?.aliasDefaultCatalog ?? true;
     let checkExists;
     let readYaml;
     let writeYaml;
@@ -194,13 +195,17 @@ function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
         let hasChanges = false;
         for (const update of updates) {
             const { packageName, version, catalogName } = update;
-            const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+            const normalizedCatalogName = aliasDefaultCatalog && catalogName === 'default'
+                ? undefined
+                : catalogName;
             let targetPath;
             if (!normalizedCatalogName) {
                 // An empty `catalog:` placeholder must not claim the default route
                 // when `catalogs.default` is populated; that would create a
-                // duplicate-default config rejected by pnpm.
-                if (isMapAt(doc, ['catalog'])) {
+                // duplicate-default config rejected by pnpm. Without the alias,
+                // "default" is an ordinary named catalog and the default route is
+                // always the `catalog` field.
+                if (!aliasDefaultCatalog || isMapAt(doc, ['catalog'])) {
                     targetPath = ['catalog', packageName];
                 }
                 else if (existsAt(doc, ['catalogs', 'default'])) {

package/dist/src/utils/catalog/manager.d.ts

@@ -1,6 +1,12 @@
 import type { Tree } from '../../generators/tree';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 export declare function formatCatalogError(error: string, suggestions: string[]): string;
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+export declare function collectCatalogReferencesForPackage(manager: CatalogManager, treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
 /**
  * Interface for catalog managers that handle package manager-specific catalog implementations.
  */
@@ -19,6 +25,12 @@ export interface CatalogManager {
      */
     resolveCatalogReference(workspaceRoot: string, packageName: string, version: string): string | null;
     resolveCatalogReference(tree: Tree, packageName: string, version: string): string | null;
+    /**
+     * Get every catalog reference that resolves to a version for a package,
+     * following the package manager's own default-catalog semantics.
+     */
+    getCatalogReferencesForPackage(workspaceRoot: string, packageName: string): CatalogReferenceMatch[];
+    getCatalogReferencesForPackage(tree: Tree, packageName: string): CatalogReferenceMatch[];
     /**
      * Check that a catalog reference is valid.
      */

package/dist/src/utils/catalog/manager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCatalogError = formatCatalogError;
+exports.collectCatalogReferencesForPackage = collectCatalogReferencesForPackage;
 function formatCatalogError(error, suggestions) {
     let message = error;
     if (suggestions.length > 0) {
@@ -11,3 +12,32 @@ function formatCatalogError(error, suggestions) {
     }
     return message;
 }
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+function collectCatalogReferencesForPackage(manager, treeOrRoot, packageName) {
+    // The overload pairs don't accept the Tree | string union directly.
+    const source = treeOrRoot;
+    const catalogDefs = manager.getCatalogDefinitions(source);
+    if (!catalogDefs) {
+        return [];
+    }
+    const catalogRefs = ['catalog:'];
+    for (const name of Object.keys(catalogDefs.catalogs ?? {})) {
+        // Skip names the manager treats as the default catalog (e.g. pnpm's
+        // "default") — already covered by the `catalog:` candidate.
+        if (!manager.parseCatalogReference(`catalog:${name}`)?.isDefaultCatalog) {
+            catalogRefs.push(`catalog:${name}`);
+        }
+    }
+    const matches = [];
+    for (const catalogRef of catalogRefs) {
+        const versionSpec = manager.resolveCatalogReference(source, packageName, catalogRef);
+        if (versionSpec) {
+            matches.push({ catalogRef, versionSpec });
+        }
+    }
+    return matches;
+}

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

@@ -1,6 +1,6 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
  * PNPM-specific catalog manager implementation
  */
@@ -13,6 +13,7 @@ export declare class PnpmCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

package/dist/src/utils/catalog/pnpm-manager.js

@@ -54,6 +54,9 @@ class PnpmCatalogManager {
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {

package/dist/src/utils/catalog/types.d.ts

@@ -2,6 +2,10 @@ export interface CatalogReference {
     catalogName?: string;
     isDefaultCatalog: boolean;
 }
+export interface CatalogReferenceMatch {
+    catalogRef: string;
+    versionSpec: string;
+}
 export interface CatalogEntry {
     [packageName: string]: string;
 }

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

@@ -1,8 +1,11 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 export declare class YarnCatalogManager implements CatalogManager {
     readonly name = "yarn";
@@ -13,6 +16,7 @@ export declare class YarnCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

package/dist/src/utils/catalog/yarn-manager.js

@@ -5,7 +5,10 @@ const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const YARNRC_FILENAME = '.yarnrc.yml';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 class YarnCatalogManager {
     constructor() {
@@ -22,8 +25,9 @@ class YarnCatalogManager {
             return null;
         }
         const catalogName = version.substring(this.catalogProtocol.length);
-        // Normalize both "catalog:" and "catalog:default" to the same representation
-        const isDefault = !catalogName || catalogName === 'default';
+        // Only an empty name selects the default catalog; unlike pnpm, "default"
+        // is a regular named catalog in yarn.
+        const isDefault = !catalogName;
         return {
             catalogName: isDefault ? undefined : catalogName,
             isDefaultCatalog: isDefault,
@@ -46,14 +50,16 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            // Check both locations for default catalog
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            catalogToUse = catalogDefs.catalog;
         }
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {
@@ -65,13 +71,9 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            const hasCatalog = !!catalogDefs.catalog;
-            const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
-            // Error if both defined
-            if (hasCatalog && hasCatalogsDefault) {
-                throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
-            }
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            // Yarn's default catalog is only the `catalog` field; unlike pnpm,
+            // `catalogs.default` does not act as a fallback.
+            catalogToUse = catalogDefs.catalog;
             if (!catalogToUse) {
                 const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
@@ -88,12 +90,7 @@ class YarnCatalogManager {
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
             if (!catalogToUse) {
-                const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== 'default');
-                const defaultCatalog = !!catalogDefs.catalog
-                    ? 'catalog'
-                    : !catalogDefs.catalogs?.default
-                        ? 'catalogs.default'
-                        : null;
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
                     `Define the catalog in ${YARNRC_FILENAME} under the "catalogs" key`,
                 ];
@@ -102,24 +99,16 @@ class YarnCatalogManager {
                         .map((c) => `"catalog:${c}"`)
                         .join(', ')}`);
                 }
-                if (defaultCatalog) {
-                    suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
                 }
                 throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${YARNRC_FILENAME}`, suggestions));
             }
         }
         if (!catalogToUse[packageName]) {
-            let catalogName;
-            if (catalogRef.isDefaultCatalog) {
-                // Context-aware messaging based on which location exists
-                const hasCatalog = !!catalogDefs.catalog;
-                catalogName = hasCatalog
-                    ? 'default catalog ("catalog")'
-                    : 'default catalog ("catalogs.default")';
-            }
-            else {
-                catalogName = `catalog '${catalogRef.catalogName}'`;
-            }
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
             const availablePackages = Object.keys(catalogToUse);
             const suggestions = [
                 `Add "${packageName}" to ${catalogName} in ${YARNRC_FILENAME}`,
@@ -133,7 +122,9 @@ class YarnCatalogManager {
         }
     }
     updateCatalogVersions(treeOrRoot, updates) {
-        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates);
+        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates, {
+            aliasDefaultCatalog: false,
+        });
     }
 }
 exports.YarnCatalogManager = YarnCatalogManager;

package/dist/src/utils/child-process.d.ts

@@ -1,7 +1,37 @@
-import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { type ExecOptions, type ExecSyncOptions, type SpawnSyncOptions } from 'child_process';
 import { PackageManagerCommands } from './package-manager';
 import { ChildProcess } from '../native';
 export declare function getRunNxBaseCommand(packageManagerCommand?: PackageManagerCommands, cwd?: string): string;
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+export declare function getNxBin(root?: string): string | null;
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+export declare function readInstalledNxBin(dir: string): string | null;
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+export declare function runNxArgvSync(argv: string[], options?: SpawnSyncOptions & {
+    cwd?: string;
+    nxBin?: string;
+}): void;
 export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
     cwd?: string;
     packageManagerCommand?: PackageManagerCommands;

package/dist/src/utils/child-process.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoTtyProcess = void 0;
 exports.getRunNxBaseCommand = getRunNxBaseCommand;
+exports.getNxBin = getNxBin;
+exports.readInstalledNxBin = readInstalledNxBin;
+exports.runNxArgvSync = runNxArgvSync;
 exports.runNxSync = runNxSync;
 exports.runNxAsync = runNxAsync;
 const child_process_1 = require("child_process");
@@ -10,9 +13,14 @@ const path_1 = require("path");
 const package_manager_1 = require("./package-manager");
 const workspace_root_1 = require("./workspace-root");
 const exit_codes_1 = require("./exit-codes");
+const fileutils_1 = require("./fileutils");
+const shell_quoting_1 = require("./shell-quoting");
 function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
         if (!packageManagerCommand) {
+            // `readLocalNxVersion` (command-line/migrate/migrate.ts) mirrors this
+            // selector to predict which nx a spawn will run, for the workspaces
+            // `getNxBin` declines to resolve; keep the two in sync.
             const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
             packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
         }
@@ -28,6 +36,101 @@ function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
         }
     }
 }
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+function getNxBin(root = workspace_root_1.workspaceRoot) {
+    // A workspace with no root package.json runs nx through the `./nx` wrapper,
+    // which reinstalls `.nx/installation` whenever it drifts from nx.json's
+    // `installation.version`. Spawning the resolved entry point would skip that
+    // sync, and a migration is precisely when the version changes.
+    if (!(0, fs_1.existsSync)((0, path_1.join)(root, 'package.json'))) {
+        return null;
+    }
+    return findInstalledNxBin(root);
+}
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+function readInstalledNxBin(dir) {
+    const packageDir = (0, path_1.join)(dir, 'node_modules', 'nx');
+    const manifest = (0, path_1.join)(packageDir, 'package.json');
+    if (!(0, fs_1.existsSync)(manifest)) {
+        return null;
+    }
+    let bin;
+    try {
+        ({ bin } = (0, fileutils_1.readJsonFile)(manifest));
+    }
+    catch {
+        return null;
+    }
+    // npm accepts both the single-entry shorthand and the map form.
+    const entry = typeof bin === 'string' ? bin : bin?.nx;
+    return typeof entry === 'string' ? (0, path_1.join)(packageDir, entry) : null;
+}
+// Ascend to the nearest installed nx and take the entry point its `bin` field
+// names, which is the file a package manager links into `node_modules/.bin`.
+// Deliberately npx-shaped: npx and bun ascend unconditionally while pnpm and
+// yarn stop at an outer workspace, so this can name an nx those two would
+// decline to run.
+//
+// Deliberately not a resolver. Resolvers answer from NODE_PATH once their
+// explicit paths miss, and `nxCliPath` (command-line/migrate/migrate.ts) points
+// NODE_PATH at the temp installation before spawning it; they also answer
+// through package self-reference, which hands back the running nx whatever
+// `paths` they are given. Either one lets the temp installation hand off to
+// itself, which for `--run-migrations` re-enters the same hand-off and respawns
+// without end.
+function findInstalledNxBin(root) {
+    for (let dir = root;; dir = (0, path_1.dirname)(dir)) {
+        // The nearest install wins, so an unusable manifest there ends the search
+        // rather than deferring to an ancestor.
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'node_modules', 'nx', 'package.json'))) {
+            return readInstalledNxBin(dir);
+        }
+        if (dir === (0, path_1.dirname)(dir)) {
+            return null;
+        }
+    }
+}
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+function runNxArgvSync(argv, options) {
+    let { nxBin, ...spawnOptions } = options ?? {};
+    spawnOptions.cwd ??= process.cwd();
+    spawnOptions.windowsHide ??= true;
+    nxBin ??= getNxBin((0, workspace_root_1.workspaceRootInner)(spawnOptions.cwd, null) ?? workspace_root_1.workspaceRoot);
+    if (!nxBin) {
+        runNxSync(argv.map(shell_quoting_1.quoteShellArg).join(' '), spawnOptions);
+        return;
+    }
+    const result = (0, child_process_1.spawnSync)(process.execPath, [nxBin, ...argv], spawnOptions);
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const error = new Error(`Command failed: nx ${argv.join(' ')} (exit code ${result.status})`);
+        error.status = result.status ?? 1;
+        throw error;
+    }
+}
 function runNxSync(cmd, options) {
     let { packageManagerCommand, ...execSyncOptions } = options ?? {};
     execSyncOptions.cwd ??= process.cwd();

package/dist/src/utils/chunkify.d.ts

@@ -1,4 +1,10 @@
-export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
+export declare function chunkify(target: string[], maxChunkLength?: number, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure?: (item: string) => number): string[][];
 /**
  * Get the maximum length of a command-line argument string based on current platform
  *