nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/plugins/package-json/create-nodes.js

@@ -16,6 +16,7 @@ const globs_1 = require("../../utils/globs");
 const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const package_json_1 = require("../../utils/package-json");
+const package_manager_1 = require("../../utils/package-manager");
 const path_1 = require("../../utils/path");
 const versions_1 = require("../../utils/versions");
 const plugins_1 = require("../../project-graph/plugins");
@@ -38,6 +39,7 @@ exports.createNodesV2 = [
             return projectJsonRoots.has((0, node_path_1.dirname)(packageJsonPath));
         };
         const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
+        const packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(context.workspaceRoot), context.workspaceRoot);
         return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
             const isInPackageManagerWorkspaces = isInPackageJsonWorkspaces(packageJsonPath);
             if (!isInPackageManagerWorkspaces &&
@@ -45,7 +47,7 @@ exports.createNodesV2 = [
                 // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
                 return null;
             }
-            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand);
         }, packageJsons, _, context);
     },
 ];
@@ -111,7 +113,7 @@ function buildPackageJsonWorkspacesMatcher(patterns) {
         !patterns.negativeLookup[p] &&
         patterns.negative.every((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
     const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
     const hash = (0, file_hasher_1.hashObject)({
@@ -128,7 +130,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
             },
         };
     }
-    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces);
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
     cache.set(hash, project);
     return {
         projects: {
@@ -136,7 +138,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
         },
     };
 }
-function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces) {
+function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces, packageManagerCommand) {
     const normalizedPath = packageJsonPath.split('\\').join('/');
     const projectRoot = (0, node_path_1.dirname)(normalizedPath);
     const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
@@ -161,7 +163,7 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
         root: projectRoot,
         name,
         ...packageJson.nx,
-        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson, projectRoot, workspaceRoot),
+        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson, projectRoot, workspaceRoot, packageManagerCommand),
         tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
         metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson, isInPackageManagerWorkspaces),
     };

package/dist/src/project-graph/affected/locators/project-glob-changes.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromProjectGlobChanges = void 0;
 const minimatch_1 = require("minimatch");
+const nx_json_1 = require("../../../config/nx-json");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const path_1 = require("path");
 const fs_1 = require("fs");
@@ -20,7 +21,7 @@ const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGra
                 'package.json',
             ]);
         }
-        const plugins = (await (0, get_plugins_1.getPlugins)()).filter((p) => !!p.createNodes);
+        const plugins = (await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot))).filter((p) => !!p.createNodes);
         return (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.getGlobPatternsOfPlugins)(plugins));
     })();
     const touchedProjects = new Set();

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

@@ -2,6 +2,7 @@ import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/proje
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 import { CreateMetadataError } from './error-types';
+import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { CreateMetadataContext } from './plugins';
 import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
@@ -9,8 +10,12 @@ import type { ConfigurationSourceMaps } from './utils/project-configuration/sour
 export declare function getFileMap(): {
     fileMap: FileMap;
     rustReferences: NxWorkspaceFilesExternals | null;
+    /** @deprecated always `[]`; kept so cached nx-cloud workers that destructure it don't see `undefined`. */
+    allWorkspaceFiles: FileData[];
 };
 export declare function hydrateFileMap(fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals): void;
+/** @deprecated pass `(fileMap, rustReferences)`. Kept for cached nx-cloud workers still on the 3-arg form. */
+export declare function hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
 export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;

package/dist/src/project-graph/build-project-graph.js

@@ -29,6 +29,7 @@ function getFileMap() {
         return {
             fileMap: storedFileMap,
             rustReferences: storedRustReferences,
+            allWorkspaceFiles: [],
         };
     }
     else {
@@ -38,12 +39,15 @@ function getFileMap() {
                 projectFileMap: {},
             },
             rustReferences: null,
+            allWorkspaceFiles: [],
         };
     }
 }
-function hydrateFileMap(fileMap, rustReferences) {
+function hydrateFileMap(fileMap, rustReferencesOrAllFiles, maybeRustReferences) {
     storedFileMap = fileMap;
-    storedRustReferences = rustReferences;
+    storedRustReferences = Array.isArray(rustReferencesOrAllFiles)
+        ? (maybeRustReferences ?? null)
+        : rustReferencesOrAllFiles;
 }
 async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;

package/dist/src/project-graph/file-map-utils.d.ts

@@ -3,6 +3,11 @@ import type { ProjectConfiguration, ProjectsConfigurations } from '../config/wor
 import { NxWorkspaceFilesExternals } from '../native';
 export interface WorkspaceFileMap {
     fileMap: FileMap;
+    /**
+     * @deprecated Derived from `fileMap.projectFileMap` + `fileMap.nonProjectFiles`.
+     * Will be removed in a future major. Compute it locally if needed.
+     */
+    allWorkspaceFiles?: FileData[];
 }
 export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
 export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Promise<WorkspaceFileMap>;

package/dist/src/project-graph/file-map-utils.js

@@ -7,6 +7,7 @@ exports.updateFileMap = updateFileMap;
 const workspace_context_1 = require("../utils/workspace-context");
 const workspace_root_1 = require("../utils/workspace-root");
 const project_graph_1 = require("./project-graph");
+const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
 const find_project_for_path_1 = require("./utils/find-project-for-path");
 async function createProjectFileMapUsingProjectGraph(graph) {
     return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
@@ -36,12 +37,20 @@ function createFileMap(projectsConfigurations, allWorkspaceFiles) {
             nonProjectFiles.push(f);
         }
     }
-    return {
+    const result = {
         fileMap: {
             projectFileMap,
             nonProjectFiles,
         },
     };
+    Object.defineProperty(result, 'allWorkspaceFiles', {
+        enumerable: false,
+        configurable: true,
+        get() {
+            return (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(result.fileMap.projectFileMap, result.fileMap.nonProjectFiles);
+        },
+    });
+    return result;
 }
 function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, deletedFiles) {
     const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);

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

@@ -1,3 +1,4 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
 import type { LoadedNxPlugin } from './loaded-nx-plugin';
 export interface SeparatedPlugins {
     specifiedPlugins: LoadedNxPlugin[];
@@ -7,14 +8,18 @@ export interface SeparatedPlugins {
  * Returns all plugins (specified + default) as a flat list.
  * Specified plugins come first, followed by default plugins.
  */
-export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+export declare function getPlugins(nxJson: NxJsonConfiguration, root?: string): Promise<LoadedNxPlugin[]>;
 /**
  * Returns specified plugins (from nx.json) and default plugins (project.json,
  * package.json, etc.) as separate arrays. This separation is needed for
  * two-phase project configuration processing where target defaults are
  * applied between specified and default plugin results.
+ *
+ * `nxJson` is required so callers control the snapshot of nx.json the plugin
+ * loader uses. This matters for the daemon's freshness-gated recompute, where
+ * the snap hash and the plugin set must reflect the same disk state.
  */
-export declare function getPluginsSeparated(root?: string): Promise<SeparatedPlugins>;
+export declare function getPluginsSeparated(nxJson: NxJsonConfiguration, root?: string): Promise<SeparatedPlugins>;
 export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
 export declare function cleanupPlugins(): void;
 export declare function reasonToError(reason: unknown): Error;

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

@@ -7,7 +7,6 @@ exports.cleanupPlugins = cleanupPlugins;
 exports.reasonToError = reasonToError;
 const node_path_1 = require("node:path");
 const angular_json_1 = require("../../adapter/angular-json");
-const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
 const workspace_root_1 = require("../../utils/workspace-root");
 const in_process_loader_1 = require("./in-process-loader");
@@ -29,8 +28,8 @@ const loadingMethod = (plugin, root, index) => (0, enabled_1.isIsolationEnabled)
  * Returns all plugins (specified + default) as a flat list.
  * Specified plugins come first, followed by default plugins.
  */
-async function getPlugins(root = workspace_root_1.workspaceRoot) {
-    const { specifiedPlugins, defaultPlugins } = await getPluginsSeparated(root);
+async function getPlugins(nxJson, root = workspace_root_1.workspaceRoot) {
+    const { specifiedPlugins, defaultPlugins } = await getPluginsSeparated(nxJson, root);
     return specifiedPlugins.concat(defaultPlugins);
 }
 /**
@@ -38,9 +37,13 @@ async function getPlugins(root = workspace_root_1.workspaceRoot) {
  * package.json, etc.) as separate arrays. This separation is needed for
  * two-phase project configuration processing where target defaults are
  * applied between specified and default plugin results.
+ *
+ * `nxJson` is required so callers control the snapshot of nx.json the plugin
+ * loader uses. This matters for the daemon's freshness-gated recompute, where
+ * the snap hash and the plugin set must reflect the same disk state.
  */
-async function getPluginsSeparated(root = workspace_root_1.workspaceRoot) {
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)(root).plugins ?? [];
+async function getPluginsSeparated(nxJson, root = workspace_root_1.workspaceRoot) {
+    const pluginsConfiguration = nxJson.plugins ?? [];
     const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
     // If the plugins configuration has not changed, reuse the current plugins
     if (cachedSeparatedPlugins &&

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

@@ -1 +1,2 @@
+import '../../../utils/enable-compile-cache';
 import '../../../utils/perf-logging';

package/dist/src/project-graph/plugins/isolation/plugin-worker.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// Must be the first import — see enable-compile-cache.ts.
+require("../../../utils/enable-compile-cache");
 const node_perf_hooks_1 = require("node:perf_hooks");
 node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- start`);
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");

package/dist/src/project-graph/plugins/resolve-plugin.d.ts

@@ -1,15 +1,18 @@
 import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+type LocalPluginMatch = {
+    path: string;
+    projectConfig: ProjectConfiguration;
+    resolvedFile?: string;
+};
 export declare function resolveNxPlugin(moduleName: string, root: string, paths: string[]): Promise<{
     pluginPath: string;
     name: any;
     shouldRegisterTSTranspiler: boolean;
 }>;
-export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
-    path: string;
-    projectConfig: ProjectConfiguration;
-} | null;
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): LocalPluginMatch | null;
 export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
     pluginPath: string;
     name: any;
     shouldRegisterTSTranspiler: boolean;
 };
+export {};

package/dist/src/project-graph/plugins/resolve-plugin.js

@@ -6,28 +6,59 @@ exports.getPluginPathAndName = getPluginPathAndName;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("node:path"));
 const node_fs_1 = require("node:fs");
+const resolve_exports_1 = require("resolve.exports");
 const packages_1 = require("../../plugins/js/utils/packages");
+const typescript_1 = require("../../plugins/js/utils/typescript");
 const fileutils_1 = require("../../utils/fileutils");
 const logger_1 = require("../../utils/logger");
 const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
 const find_project_for_path_1 = require("../utils/find-project-for-path");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const TS_SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.mts']);
 let projectsWithoutInference;
 let projectsWithoutInferencePromise = null;
 async function resolveNxPlugin(moduleName, root, paths) {
-    try {
-        require.resolve(moduleName, { paths });
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInferencePromise ??=
-            (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-        projectsWithoutInference ??= await projectsWithoutInferencePromise;
+    // Default plugins (see `getDefaultPlugins` in `get-plugins.ts`) are passed
+    // as absolute file paths to compiled bundles inside `nx` itself; they are
+    // never workspace-local. Skip the project load entirely for them to avoid
+    // recursing through `retrieveProjectConfigurationsWithoutPluginInference`,
+    // which itself triggers default-plugin loading.
+    if (!path.isAbsolute(moduleName)) {
+        let resolvedFromNode;
+        try {
+            resolvedFromNode = require.resolve(moduleName, { paths });
+        }
+        catch { }
+        // Load projects if Node couldn't resolve (so the local fallback can run)
+        // OR if Node resolved to a workspace-internal path (a symlinked workspace
+        // package whose source-first lookup should win over the symlinked dist).
+        if (!resolvedFromNode ||
+            isWorkspaceLocalResolution(resolvedFromNode, root)) {
+            projectsWithoutInferencePromise ??=
+                (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+            projectsWithoutInference ??= await projectsWithoutInferencePromise;
+        }
     }
     const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
+/**
+ * Distinguishes a symlinked workspace package (where `require.resolve`
+ * follows the package-manager symlink into the workspace source tree) from
+ * a truly-installed dependency under `node_modules/`. The former needs the
+ * source-first lookup to bypass the dist that Node would otherwise return.
+ */
+function isWorkspaceLocalResolution(resolvedPath, root) {
+    const normalizedRoot = path.normalize(root);
+    const normalizedPath = path.normalize(resolvedPath);
+    return (normalizedPath.startsWith(normalizedRoot + path.sep) &&
+        !normalizedPath.includes(path.sep + 'node_modules' + path.sep));
+}
+function isPackageResolutionError(e) {
+    const code = e.code;
+    return (code === 'MODULE_NOT_FOUND' || code === 'ERR_PACKAGE_PATH_NOT_EXPORTED');
+}
 function readPluginMainFromProjectConfiguration(plugin) {
     const { main } = Object.values(plugin.targets).find((x) => [
         '@nx/js:tsc',
@@ -46,31 +77,44 @@ function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.work
 }
 function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
-    let shouldRegisterTSTranspiler = false;
-    try {
-        pluginPath = require.resolve(moduleName, {
-            paths,
-        });
-        const extension = path.extname(pluginPath);
-        shouldRegisterTSTranspiler = extension === '.ts';
+    // Resolve local workspace plugins from source first so the workspace's
+    // `customConditions`/`development` exports condition wins over the built
+    // `dist` artifact that Node's resolver would otherwise pick up via the
+    // `default` condition (Node ignores TypeScript custom conditions). Skipped
+    // when `projects` weren't loaded — the caller already determined that the
+    // import isn't a workspace package.
+    const localPlugin = projects
+        ? resolveLocalNxPlugin(moduleName, projects, root)
+        : null;
+    if (localPlugin) {
+        pluginPath = tryResolveLocalPluginFromSource(moduleName, localPlugin, root);
+        if (!pluginPath && getSubpathOfLocalPackage(moduleName, localPlugin)) {
+            throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+        }
     }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
-            if (plugin) {
-                shouldRegisterTSTranspiler = true;
-                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
-                pluginPath = main ? path.join(root, main) : plugin.path;
+    if (!pluginPath) {
+        try {
+            pluginPath = require.resolve(moduleName, { paths });
+        }
+        catch (e) {
+            if (localPlugin && isPackageResolutionError(e)) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
             }
-            else {
-                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+            if (e.code !== 'MODULE_NOT_FOUND') {
                 throw e;
             }
-        }
-        else {
+            if (localPlugin) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+            }
+            logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
             throw e;
         }
     }
+    const ext = path.extname(pluginPath);
+    // Directory paths fall through to Node's `package.json` `main` resolution
+    // which may land on a TS file; only opt out of TS transpiler registration
+    // when the resolved path is unambiguously JS.
+    const shouldRegisterTSTranspiler = ext === '' || TS_SOURCE_EXTENSIONS.has(ext);
     const packageJsonPath = path.join(pluginPath, 'package.json');
     const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
         (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
@@ -78,12 +122,84 @@ function getPluginPathAndName(moduleName, paths, projects, root) {
         : { name: moduleName };
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
+function getSubpathOfLocalPackage(moduleName, plugin) {
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (!packageName || !moduleName.startsWith(packageName + '/')) {
+        return null;
+    }
+    return '.' + moduleName.slice(packageName.length);
+}
+function tryResolveLocalPluginFromSource(moduleName, plugin, root) {
+    if (plugin.resolvedFile) {
+        return plugin.resolvedFile;
+    }
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    if (subpath) {
+        return resolveSubpathFromExports(plugin.projectConfig, plugin.path, subpath, root);
+    }
+    const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+    return main ? path.join(root, main) : null;
+}
+function throwUnresolvableLocalPluginError(moduleName, plugin, root) {
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (subpath) {
+        throw new Error(`Unable to resolve local plugin "${moduleName}". The import targets ` +
+            `the subpath "${subpath}" of the local package "${packageName}", but ` +
+            `the package's "exports" map has no resolvable entry for "${subpath}", ` +
+            `or none of the matched paths exist on disk. Check the "exports" field ` +
+            `in "${path.relative(root, path.join(plugin.path, 'package.json'))}" ` +
+            `and ensure the source file referenced by "${subpath}" exists.`);
+    }
+    throw new Error(`Unable to resolve local plugin "${moduleName}". The local package ` +
+        `"${packageName ?? moduleName}" does not declare a build target with ` +
+        `a "main" source path, and Node could not resolve it either.`);
+}
+function resolveSubpathFromExports(projectConfig, projectPath, subpath, root) {
+    const packageExports = projectConfig.metadata?.js?.packageExports;
+    if (!packageExports) {
+        return null;
+    }
+    const pkg = {
+        name: projectConfig.metadata.js.packageName,
+        exports: packageExports,
+    };
+    try {
+        const matches = (0, resolve_exports_1.resolve)(pkg, subpath, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(root),
+        });
+        if (!matches || !matches.length) {
+            return null;
+        }
+        for (const match of matches) {
+            const candidate = path.join(projectPath, match);
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to resolve subpath "${subpath}" of local plugin via package.json exports`, e);
+    }
+    return null;
+}
 function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
-    if (!projectConfig) {
+    const match = findNxProjectForImportPath(importPath, projects, root);
+    if (!match) {
         return null;
     }
-    return { path: path.join(root, projectConfig.root), projectConfig };
+    let resolvedFile;
+    if (match.tsPathFile) {
+        const candidate = path.join(root, match.tsPathFile);
+        if (path.extname(candidate) && (0, node_fs_1.existsSync)(candidate)) {
+            resolvedFile = candidate;
+        }
+    }
+    return {
+        path: path.join(root, match.projectConfig.root),
+        projectConfig: match.projectConfig,
+        resolvedFile,
+    };
 }
 let packageEntryPointsToProjectMap;
 let wildcardEntryPointsToProjectMap;
@@ -101,7 +217,10 @@ function findNxProjectForImportPath(importPath, projects, root = workspace_root_
         for (const tsConfigPath of possibleTsPaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
-                return projectNameMap.get(nxProject);
+                return {
+                    projectConfig: projectNameMap.get(nxProject),
+                    tsPathFile: tsConfigPath,
+                };
             }
         }
     }
@@ -112,14 +231,14 @@ function findNxProjectForImportPath(importPath, projects, root = workspace_root_
         } = (0, packages_1.getWorkspacePackagesMetadata)(projects));
     }
     if (packageEntryPointsToProjectMap[importPath]) {
-        return packageEntryPointsToProjectMap[importPath];
+        return { projectConfig: packageEntryPointsToProjectMap[importPath] };
     }
     const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(wildcardEntryPointsToProjectMap, importPath);
     if (project) {
-        return project;
+        return { projectConfig: project };
     }
     logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
-    throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    return null;
 }
 let tsconfigPaths;
 function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {

package/dist/src/project-graph/plugins/tasks-execution-hooks.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runPreTasksExecution = runPreTasksExecution;
 exports.runPostTasksExecution = runPostTasksExecution;
+const nx_json_1 = require("../../config/nx-json");
 const get_plugins_1 = require("./get-plugins");
 const is_on_daemon_1 = require("../../daemon/is-on-daemon");
 const client_1 = require("../../daemon/client/client");
+const workspace_root_1 = require("../../utils/workspace-root");
 async function runPreTasksExecution(pluginContext) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
         performance.mark(`preTasksExecution:start`);
-        const plugins = await (0, get_plugins_1.getPlugins)(pluginContext.workspaceRoot);
+        const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(pluginContext.workspaceRoot), pluginContext.workspaceRoot);
         const envs = await Promise.all(plugins
             .filter((p) => p.preTasksExecution)
             .map(async (plugin) => {
@@ -43,7 +45,7 @@ function applyProcessEnvs(envs) {
 async function runPostTasksExecution(context) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
         performance.mark(`postTasksExecution:start`);
-        const plugins = await (0, get_plugins_1.getPlugins)();
+        const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot));
         await Promise.all(plugins
             .filter((p) => p.postTasksExecution)
             .map(async (plugin) => {

package/dist/src/project-graph/plugins/transpiler.d.ts

@@ -2,7 +2,19 @@ export declare let unregisterPluginTSTranspiler: (() => void) | null;
 /**
  * Register swc-node or ts-node if they are not currently registered
  * with some default settings which work well for Nx plugins.
+ *
+ * When the runtime supports native TypeScript stripping and the user hasn't
+ * opted out, this is a noop - Node loads plugin `.ts` files directly. The
+ * lazy fallback in `handleImport` will call `forceRegisterPluginTSTranspiler`
+ * if a plugin uses unsupported syntax (enum, runtime namespace, etc.).
  */
 export declare function registerPluginTSTranspiler(): void;
+/**
+ * Always register swc-node or ts-node + tsconfig-paths, ignoring the native
+ * strip preference. Called from the fallback path in `handleImport` when a
+ * plugin `.ts` file throws `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` under native
+ * stripping.
+ */
+export declare function forceRegisterPluginTSTranspiler(): void;
 export declare function pluginTranspilerIsRegistered(): boolean;
 export declare function cleanupPluginTSTranspiler(): void;

package/dist/src/project-graph/plugins/transpiler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unregisterPluginTSTranspiler = void 0;
 exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+exports.forceRegisterPluginTSTranspiler = forceRegisterPluginTSTranspiler;
 exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
 exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
 const node_fs_1 = require("node:fs");
@@ -10,11 +11,47 @@ const register_1 = require("../../plugins/js/utils/register");
 const typescript_1 = require("../../plugins/js/utils/typescript");
 const workspace_root_1 = require("../../utils/workspace-root");
 exports.unregisterPluginTSTranspiler = null;
+const NOOP = () => { };
 /**
  * Register swc-node or ts-node if they are not currently registered
  * with some default settings which work well for Nx plugins.
+ *
+ * When the runtime supports native TypeScript stripping and the user hasn't
+ * opted out, this is a noop - Node loads plugin `.ts` files directly. The
+ * lazy fallback in `handleImport` will call `forceRegisterPluginTSTranspiler`
+ * if a plugin uses unsupported syntax (enum, runtime namespace, etc.).
  */
 function registerPluginTSTranspiler() {
+    if (exports.unregisterPluginTSTranspiler !== null) {
+        return;
+    }
+    if ((0, register_1.isNativeStripPreferred)()) {
+        // Sentinel so pluginTranspilerIsRegistered() reports true and callers
+        // don't keep retrying. The actual transpiler stays unregistered until
+        // a fallback forces it.
+        exports.unregisterPluginTSTranspiler = NOOP;
+        return;
+    }
+    doRegisterPluginTSTranspiler();
+}
+/**
+ * Always register swc-node or ts-node + tsconfig-paths, ignoring the native
+ * strip preference. Called from the fallback path in `handleImport` when a
+ * plugin `.ts` file throws `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` under native
+ * stripping.
+ */
+function forceRegisterPluginTSTranspiler() {
+    // If the previous registration was the native-strip sentinel, throw it
+    // out so we actually wire up swc/ts-node.
+    if (exports.unregisterPluginTSTranspiler === NOOP) {
+        exports.unregisterPluginTSTranspiler = null;
+    }
+    if (exports.unregisterPluginTSTranspiler !== null) {
+        return;
+    }
+    doRegisterPluginTSTranspiler();
+}
+function doRegisterPluginTSTranspiler() {
     // Get the first tsconfig that matches the allowed set
     const tsConfigName = [
         (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),