nx 20.3.0 → 20.3.2

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Narwhal Technologies Inc.
+Copyright (c) 2017-2025 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/package.json

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

package/src/command-line/release/version.js

@@ -313,6 +313,14 @@ function createAPI(overrideReleaseConfig) {
                 });
             }
         }
+        if (args.gitPush ?? nxReleaseConfig.version.git.push) {
+            output_1.output.logSingleLine(`Pushing to git remote "${args.gitRemote}"`);
+            await (0, git_1.gitPush)({
+                gitRemote: args.gitRemote,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
         return {
             workspaceVersion,
             projectsVersionData: versionData,

package/src/daemon/server/server.js

@@ -181,8 +181,8 @@ async function handleResult(socket, type, hrFn) {
     logger_1.serverLogger.log(`Handled ${type}. Handling time: ${doneHandlingMark.getTime() - startMark.getTime()}. Response time: ${endMark.getTime() - doneHandlingMark.getTime()}.`);
 }
 function handleInactivityTimeout() {
-    if (numberOfOpenConnections > 0) {
-        logger_1.serverLogger.log(`There are ${numberOfOpenConnections} open connections. Reset inactivity timer.`);
+    if ((0, file_watcher_sockets_1.hasRegisteredFileWatcherSockets)()) {
+        logger_1.serverLogger.log(`There are open file watchers. Resetting inactivity timer.`);
         (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     }
     else {

package/src/devkit-internals.d.ts

@@ -20,7 +20,7 @@ export { hashObject } from './hasher/file-hasher';
 export { hashWithWorkspaceContext } from './utils/workspace-context';
 export { createProjectRootMappingsFromProjectConfigurations, findProjectForPath, } from './project-graph/utils/find-project-for-path';
 export { retrieveProjectConfigurations } from './project-graph/utils/retrieve-workspace-files';
-export { LoadedNxPlugin } from './project-graph/plugins/internal-api';
+export { LoadedNxPlugin } from './project-graph/plugins/loaded-nx-plugin';
 export * from './project-graph/error-types';
 export { registerTsProject } from './plugins/js/utils/register';
 export { interpolate } from './tasks-runner/utils';

package/src/devkit-internals.js

@@ -43,8 +43,8 @@ Object.defineProperty(exports, "createProjectRootMappingsFromProjectConfiguratio
 Object.defineProperty(exports, "findProjectForPath", { enumerable: true, get: function () { return find_project_for_path_1.findProjectForPath; } });
 var retrieve_workspace_files_2 = require("./project-graph/utils/retrieve-workspace-files");
 Object.defineProperty(exports, "retrieveProjectConfigurations", { enumerable: true, get: function () { return retrieve_workspace_files_2.retrieveProjectConfigurations; } });
-var internal_api_1 = require("./project-graph/plugins/internal-api");
-Object.defineProperty(exports, "LoadedNxPlugin", { enumerable: true, get: function () { return internal_api_1.LoadedNxPlugin; } });
+var loaded_nx_plugin_1 = require("./project-graph/plugins/loaded-nx-plugin");
+Object.defineProperty(exports, "LoadedNxPlugin", { enumerable: true, get: function () { return loaded_nx_plugin_1.LoadedNxPlugin; } });
 tslib_1.__exportStar(require("./project-graph/error-types"), exports);
 var register_1 = require("./plugins/js/utils/register");
 Object.defineProperty(exports, "registerTsProject", { enumerable: true, get: function () { return register_1.registerTsProject; } });

package/src/nx-cloud/update-manager.js

@@ -10,6 +10,7 @@ const debug_logger_1 = require("./debug-logger");
 const tar = require("tar-stream");
 const cache_directory_1 = require("../utils/cache-directory");
 const crypto_1 = require("crypto");
+const workspace_root_1 = require("../utils/workspace-root");
 class NxCloudEnterpriseOutdatedError extends Error {
     constructor(url) {
         super(`Nx Cloud instance hosted at ${url} is outdated`);
@@ -83,7 +84,18 @@ async function verifyOrUpdateNxCloudClient(options) {
         nxCloudClient: require(currentBundle.fullPath),
     };
 }
-const runnerBundleInstallDirectory = (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+function getBundleInstallDefaultLocation() {
+    const legacyPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'node_modules', '.cache', 'nx', 'cloud');
+    // this legacy path is used when the nx-cloud package is installed.
+    // make sure to reuse it so that we don't `require` different the client bundles
+    if ((0, fs_1.existsSync)(legacyPath)) {
+        return legacyPath;
+    }
+    else {
+        return (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+    }
+}
+const runnerBundleInstallDirectory = getBundleInstallDefaultLocation();
 function getLatestInstalledRunnerBundle() {
     if (!(0, fs_1.existsSync)(runnerBundleInstallDirectory)) {
         (0, fs_1.mkdirSync)(runnerBundleInstallDirectory, { recursive: true });

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -191,7 +191,10 @@ class TargetProjectLocator {
     }
     findDependencyInWorkspaceProjects(dep) {
         this.packageEntryPointsToProjectMap ??= (0, packages_1.getPackageEntryPointsToProjectMap)(this.nodes);
-        return this.packageEntryPointsToProjectMap[dep]?.name ?? null;
+        return (this.packageEntryPointsToProjectMap[dep]?.name ??
+            // if the package exports do not include ".", look for subpath exports
+            Object.entries(this.packageEntryPointsToProjectMap).find(([entryPoint]) => dep.startsWith(`${entryPoint}/`))?.[1]?.name ??
+            null);
     }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;

package/src/plugins/js/utils/packages.js

@@ -10,14 +10,28 @@ function getPackageEntryPointsToProjectMap(projects) {
             continue;
         }
         const { packageName, packageExports } = metadata.js;
-        if (!packageExports || typeof packageExports === 'string') {
+        if (!packageExports ||
+            typeof packageExports === 'string' ||
+            !Object.keys(packageExports).length) {
             // no `exports` or it points to a file, which would be the equivalent of
             // an '.' export, in which case the package name is the entry point
             result[packageName] = project;
         }
         else {
             for (const entryPoint of Object.keys(packageExports)) {
-                result[(0, posix_1.join)(packageName, entryPoint)] = project;
+                // if entrypoint begins with '.', it is a relative subpath export
+                // otherwise, it is a conditional export
+                // https://nodejs.org/api/packages.html#conditional-exports
+                if (entryPoint.startsWith('.')) {
+                    result[(0, posix_1.join)(packageName, entryPoint)] = project;
+                }
+                else {
+                    result[packageName] = project;
+                }
+            }
+            // if there was no '.' entrypoint, ensure the package name is matched with the project
+            if (!result[packageName]) {
+                result[packageName] = project;
             }
         }
     }

package/src/project-graph/build-project-graph.d.ts

@@ -1,6 +1,6 @@
 import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
-import { LoadedNxPlugin } from './plugins/internal-api';
+import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
 import { CreateMetadataContext } from './plugins';
 import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';

package/src/project-graph/error-types.d.ts

@@ -4,6 +4,7 @@ import { ProjectGraph } from '../config/project-graph';
 import { CreateNodesFunctionV2 } from './plugins/public-api';
 export declare class ProjectGraphError extends Error {
     #private;
+    private readonly errors;
     constructor(errors: Array<AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
@@ -83,6 +84,7 @@ export declare class AggregateCreateNodesError extends Error {
      */
     constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>);
 }
+export declare function formatAggregateCreateNodesError(error: AggregateCreateNodesError, pluginName: string): void;
 export declare class MergeNodesError extends Error {
     file: string;
     pluginName: string;

package/src/project-graph/error-types.js

@@ -1,5 +1,5 @@
 "use strict";
-var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
+var _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadPluginError = exports.DaemonProjectGraphError = exports.AggregateProjectGraphError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.ProjectConfigurationsError = exports.ProjectWithNoNameError = exports.ProjectsWithNoNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = void 0;
 exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
@@ -7,6 +7,7 @@ exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameErro
 exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
 exports.isProjectWithNoNameError = isProjectWithNoNameError;
 exports.isProjectConfigurationsError = isProjectConfigurationsError;
+exports.formatAggregateCreateNodesError = formatAggregateCreateNodesError;
 exports.isWorkspaceValidityError = isWorkspaceValidityError;
 exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
 exports.isCreateMetadataError = isCreateMetadataError;
@@ -15,17 +16,45 @@ exports.isMergeNodesError = isMergeNodesError;
 const tslib_1 = require("tslib");
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
-        super(`Failed to process project graph. Run "nx reset" to fix this. Please report the issue if you keep seeing it.`);
-        _ProjectGraphError_errors.set(this, void 0);
+        const messageFragments = ['Failed to process project graph.'];
+        const mergeNodesErrors = [];
+        const unknownErrors = [];
+        for (const e of errors) {
+            if (
+            // Known errors that are self-explanatory
+            isAggregateCreateNodesError(e) ||
+                isCreateMetadataError(e) ||
+                isProcessDependenciesError(e) ||
+                isProjectsWithNoNameError(e) ||
+                isMultipleProjectsWithSameNameError(e) ||
+                isWorkspaceValidityError(e)) {
+            }
+            else if (
+            // Known error type, but unlikely to be caused by the user
+            isMergeNodesError(e)) {
+                mergeNodesErrors.push(e);
+            }
+            else {
+                unknownErrors.push(e);
+            }
+        }
+        if (mergeNodesErrors.length > 0) {
+            messageFragments.push(`This type of error most likely points to an issue within Nx. Please report it.`);
+        }
+        if (unknownErrors.length > 0) {
+            messageFragments.push(`If the error cause is not obvious from the below error messages, running "nx reset" may fix it. Please report the issue if you keep seeing it.`);
+        }
+        super(messageFragments.join(' '));
+        this.errors = errors;
         _ProjectGraphError_partialProjectGraph.set(this, void 0);
         _ProjectGraphError_partialSourceMaps.set(this, void 0);
         this.name = this.constructor.name;
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
+        this.errors = errors;
         tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
         tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
-        this.stack = `${this.message}\n  ${errors
+        this.stack = errors
             .map((error) => indentString(formatErrorStackAndCause(error), 2))
-            .join('\n')}`;
+            .join('\n');
     }
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
@@ -47,11 +76,11 @@ class ProjectGraphError extends Error {
         return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
     }
     getErrors() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
+        return this.errors;
     }
 }
 exports.ProjectGraphError = ProjectGraphError;
-_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
+_ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 class MultipleProjectsWithSameNameError extends Error {
     constructor(conflicts, projects) {
         super([
@@ -179,6 +208,29 @@ class AggregateCreateNodesError extends Error {
     }
 }
 exports.AggregateCreateNodesError = AggregateCreateNodesError;
+function formatAggregateCreateNodesError(error, pluginName) {
+    const errorBodyLines = [
+        `${error.errors.length > 1 ? `${error.errors.length} errors` : 'An error'} occurred while processing files for the ${pluginName} plugin.`,
+    ];
+    const errorStackLines = [];
+    const innerErrors = error.errors;
+    for (const [file, e] of innerErrors) {
+        if (file) {
+            errorBodyLines.push(`  - ${file}: ${e.message}`);
+            errorStackLines.push(` - ${file}: ${e.stack}`);
+        }
+        else {
+            errorBodyLines.push(`  - ${e.message}`);
+            errorStackLines.push(` - ${e.stack}`);
+        }
+        if (e.stack && process.env.NX_VERBOSE_LOGGING === 'true') {
+            const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+            errorStackLines.push(innerStackTrace);
+        }
+    }
+    error.stack = errorStackLines.join('\n');
+    error.message = errorBodyLines.join('\n');
+}
 class MergeNodesError extends Error {
     constructor({ file, pluginName, error, }) {
         const msg = `The nodes created from ${file} by the "${pluginName}" could not be merged into the project graph:`;
@@ -212,6 +264,12 @@ class ProcessDependenciesError extends Error {
     }
 }
 exports.ProcessDependenciesError = ProcessDependenciesError;
+function isProcessDependenciesError(e) {
+    return (e instanceof ProcessDependenciesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProcessDependenciesError.name));
+}
 class WorkspaceValidityError extends Error {
     constructor(message) {
         message = `Configuration Error\n${message}`;

package/src/project-graph/plugins/get-plugins.d.ts

@@ -1,4 +1,4 @@
-import { LoadedNxPlugin } from './internal-api';
-export declare function getPlugins(): Promise<LoadedNxPlugin[]>;
-export declare function getOnlyDefaultPlugins(): Promise<LoadedNxPlugin[]>;
+import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
 export declare function cleanupPlugins(): void;

package/src/project-graph/plugins/get-plugins.js

@@ -3,16 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPlugins = getPlugins;
 exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
 exports.cleanupPlugins = cleanupPlugins;
-const file_hasher_1 = require("../../hasher/file-hasher");
+const node_path_1 = require("node:path");
+const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
-const internal_api_1 = require("./internal-api");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const native_1 = require("../../native");
 const workspace_root_1 = require("../../utils/workspace-root");
+const isolation_1 = require("./isolation");
+const in_process_loader_1 = require("./in-process-loader");
+const transpiler_1 = require("./transpiler");
+/**
+ * Stuff for specified NX Plugins.
+ */
 let currentPluginsConfigurationHash;
 let loadedPlugins;
 let pendingPluginsPromise;
 let cleanup;
-async function getPlugins() {
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+async function getPlugins(root = workspace_root_1.workspaceRoot) {
+    const pluginsConfiguration = (0, nx_json_1.readNxJson)(root).plugins ?? [];
     const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
     // If the plugins configuration has not changed, reuse the current plugins
     if (loadedPlugins &&
@@ -24,17 +32,23 @@ async function getPlugins() {
         pendingPluginsPromise = undefined;
         cleanup();
     }
-    pendingPluginsPromise ??= (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
+    pendingPluginsPromise ??= loadSpecifiedNxPlugins(pluginsConfiguration, root);
     currentPluginsConfigurationHash = pluginsConfigurationHash;
-    const [result, cleanupFn] = await pendingPluginsPromise;
+    const [[result, cleanupFn], defaultPlugins] = await Promise.all([
+        pendingPluginsPromise,
+        getOnlyDefaultPlugins(root),
+    ]);
     cleanup = cleanupFn;
-    loadedPlugins = result;
-    return result;
+    loadedPlugins = result.concat(defaultPlugins);
+    return loadedPlugins;
 }
+/**
+ * Stuff for default NX Plugins.
+ */
 let loadedDefaultPlugins;
 let cleanupDefaultPlugins;
 let pendingDefaultPluginPromise;
-async function getOnlyDefaultPlugins() {
+async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
     // If the plugins configuration has not changed, reuse the current plugins
     if (loadedDefaultPlugins) {
         return loadedPlugins;
@@ -44,7 +58,7 @@ async function getOnlyDefaultPlugins() {
         pendingDefaultPluginPromise = undefined;
         cleanupDefaultPlugins();
     }
-    pendingDefaultPluginPromise ??= (0, internal_api_1.loadNxPlugins)([], workspace_root_1.workspaceRoot);
+    pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspace_root_1.workspaceRoot);
     const [result, cleanupFn] = await pendingDefaultPluginPromise;
     cleanupDefaultPlugins = cleanupFn;
     loadedPlugins = result;
@@ -53,6 +67,92 @@ async function getOnlyDefaultPlugins() {
 function cleanupPlugins() {
     pendingPluginsPromise = undefined;
     pendingDefaultPluginPromise = undefined;
-    cleanup();
-    cleanupDefaultPlugins();
+    cleanup?.();
+    cleanupDefaultPlugins?.();
+}
+/**
+ * Stuff for generic loading
+ */
+function isIsolationEnabled() {
+    // Explicitly enabled, regardless of further conditions
+    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}
+const loadingMethod = isIsolationEnabled()
+    ? isolation_1.loadNxPluginInIsolation
+    : in_process_loader_1.loadNxPlugin;
+async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
+    performance.mark('loadDefaultNxPlugins:start');
+    const plugins = getDefaultPlugins(root);
+    const cleanupFunctions = [];
+    const ret = [
+        await Promise.all(plugins.map(async (plugin) => {
+            performance.mark(`Load Nx Plugin: ${plugin} - start`);
+            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+            cleanupFunctions.push(cleanup);
+            const res = await loadedPluginPromise;
+            performance.mark(`Load Nx Plugin: ${plugin} - end`);
+            performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
+            return res;
+        })),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                (0, transpiler_1.cleanupPluginTSTranspiler)();
+            }
+        },
+    ];
+    performance.mark('loadDefaultNxPlugins:end');
+    performance.measure('loadDefaultNxPlugins', 'loadDefaultNxPlugins:start', 'loadDefaultNxPlugins:end');
+    return ret;
+}
+async function loadSpecifiedNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
+    performance.mark('loadSpecifiedNxPlugins:start');
+    plugins ??= [];
+    const cleanupFunctions = [];
+    const ret = [
+        await Promise.all(plugins.map(async (plugin) => {
+            const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
+            performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
+            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+            cleanupFunctions.push(cleanup);
+            const res = await loadedPluginPromise;
+            performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
+            performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
+            return res;
+        })),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                (0, transpiler_1.cleanupPluginTSTranspiler)();
+            }
+        },
+    ];
+    performance.mark('loadSpecifiedNxPlugins:end');
+    performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
+    return ret;
+}
+function getDefaultPlugins(root) {
+    return [
+        (0, node_path_1.join)(__dirname, '../../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [(0, node_path_1.join)(__dirname, '../../adapter/angular-json')]
+            : []),
+        (0, node_path_1.join)(__dirname, '../../plugins/package-json'),
+        (0, node_path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
+    ];
 }

package/src/project-graph/plugins/in-process-loader.d.ts

@@ -0,0 +1,10 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PackageJson } from '../../utils/package-json';
+import type { PluginConfiguration } from '../../config/nx-json';
+import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function loadNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/in-process-loader.js

@@ -0,0 +1,60 @@
+"use strict";
+// This file contains methods and utilities that should **only** be used by the plugin worker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPluginPackageJson = readPluginPackageJson;
+exports.loadNxPlugin = loadNxPlugin;
+exports.loadNxPluginAsync = loadNxPluginAsync;
+const installation_directory_1 = require("../../utils/installation-directory");
+const package_json_1 = require("../../utils/package-json");
+const fileutils_1 = require("../../utils/fileutils");
+const error_types_1 = require("../error-types");
+const path = require("node:path/posix");
+const load_resolved_plugin_1 = require("./load-resolved-plugin");
+const resolve_plugin_1 = require("./resolve-plugin");
+const transpiler_1 = require("./transpiler");
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const localPluginPath = (0, resolve_plugin_1.resolveLocalNxPlugin)(pluginName, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                    (0, transpiler_1.registerPluginTSTranspiler)();
+                }
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+function loadNxPlugin(plugin, root) {
+    return [
+        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
+        () => { },
+    ];
+}
+async function loadNxPluginAsync(pluginConfiguration, paths, root) {
+    const moduleName = typeof pluginConfiguration === 'string'
+        ? pluginConfiguration
+        : pluginConfiguration.plugin;
+    try {
+        const { pluginPath, name, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, paths);
+        if (shouldRegisterTSTranspiler) {
+            (0, transpiler_1.registerPluginTSTranspiler)();
+        }
+        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
+    }
+    catch (e) {
+        throw new error_types_1.LoadPluginError(moduleName, e);
+    }
+}

package/src/project-graph/plugins/index.d.ts

@@ -1,3 +1,4 @@
 export * from './public-api';
-export { readPluginPackageJson, registerPluginTSTranspiler } from './loader';
+export { readPluginPackageJson } from './in-process-loader';
+export { registerPluginTSTranspiler } from './transpiler';
 export { createNodesFromFiles } from './utils';

package/src/project-graph/plugins/index.js

@@ -4,8 +4,9 @@ exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.read
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./public-api"), exports);
 // export * from './get-plugins';
-var loader_1 = require("./loader");
-Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return loader_1.readPluginPackageJson; } });
-Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return loader_1.registerPluginTSTranspiler; } });
+var in_process_loader_1 = require("./in-process-loader");
+Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return in_process_loader_1.readPluginPackageJson; } });
+var transpiler_1 = require("./transpiler");
+Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return transpiler_1.registerPluginTSTranspiler; } });
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return utils_1.createNodesFromFiles; } });

package/src/project-graph/plugins/isolation/index.d.ts

@@ -1,3 +1,3 @@
-import { PluginConfiguration } from '../../../config/nx-json';
-import { LoadedNxPlugin } from '../internal-api';
+import type { PluginConfiguration } from '../../../config/nx-json';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
 export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -1,7 +1,7 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
 import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2 } from '../public-api';
-import { LoadedNxPlugin } from '../internal-api';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
 import { Serializable } from 'child_process';
 import { Socket } from 'net';
 export interface PluginWorkerLoadMessage {

package/src/project-graph/plugins/isolation/plugin-pool.d.ts

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
-import { LoadedNxPlugin } from '../internal-api';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
 export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<[Promise<LoadedNxPlugin>, () => void]>;

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -8,7 +8,7 @@ const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const messaging_1 = require("./messaging");
 const installation_directory_1 = require("../../../utils/installation-directory");
-const loader_1 = require("../loader");
+const resolve_plugin_1 = require("../resolve-plugin");
 const cleanupFunctions = new Set();
 const pluginNames = new Map();
 const PLUGIN_TIMEOUT_HINT_TEXT = 'As a last resort, you can set NX_PLUGIN_NO_TIMEOUTS=true to bypass this timeout.';
@@ -31,7 +31,7 @@ async function loadRemoteNxPlugin(plugin, root) {
         return [nxPluginWorkerCache.get(cacheKey), () => { }];
     }
     const moduleName = typeof plugin === 'string' ? plugin : plugin.plugin;
-    const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, loader_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
+    const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
     const { worker, socket } = await startPluginWorker();
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);