nx 23.3.0-beta.4 → 23.3.0-beta.6

package/dist/src/native/transform-objects.js

@@ -1,7 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformProjectGraphForRust = transformProjectGraphForRust;
+exports.transformProjectGraphForLocators = transformProjectGraphForLocators;
+exports.toRustProjectGraph = toRustProjectGraph;
+const index_1 = require("./index");
+/**
+ * Keyed by graph identity, but weak so a replaced graph is collectable. A run's
+ * hasher reuses what affected's planner already copied.
+ */
+const transferred = new WeakMap();
+/** The graph copied into Rust, once per graph. */
 function transformProjectGraphForRust(graph) {
+    let ref = transferred.get(graph);
+    if (!ref) {
+        ref = (0, index_1.transferProjectGraph)(toRustProjectGraph(graph));
+        transferred.set(graph, ref);
+    }
+    return ref;
+}
+/** Per graph like `transferred`: `nx release` runs the locators once per commit. */
+const transferredForLocators = new WeakMap();
+/**
+ * Only what the touched-project locators read: project roots, named inputs and
+ * target inputs. Copying target options and every edge costs several times
+ * what the locators themselves do on a large workspace.
+ */
+function transformProjectGraphForLocators(graph) {
+    let ref = transferredForLocators.get(graph);
+    if (!ref) {
+        const nodes = {};
+        for (const [name, node] of Object.entries(graph.nodes)) {
+            const targets = {};
+            for (const [target, config] of Object.entries(node.data.targets ?? {})) {
+                targets[target] = { inputs: config.inputs };
+            }
+            nodes[name] = {
+                root: node.data.root,
+                namedInputs: node.data.namedInputs,
+                targets,
+            };
+        }
+        ref = (0, index_1.transferProjectGraph)({ nodes, externalNodes: {}, dependencies: {} });
+        transferredForLocators.set(graph, ref);
+    }
+    return ref;
+}
+/** The graph in Rust's shape, still a JS object. Uncached, so safe to edit. */
+function toRustProjectGraph(graph) {
     const dependencies = {};
     const nodes = {};
     const externalNodes = {};
@@ -32,6 +77,7 @@ function transformProjectGraphForRust(graph) {
     }
     for (const [projectName, externalNode] of Object.entries(graph.externalNodes ?? {})) {
         externalNodes[projectName] = {
+            type: externalNode.type,
             packageName: externalNode.data.packageName,
             hash: externalNode.data.hash,
             version: externalNode.data.version,

package/dist/src/nx-cloud/update-manager.d.ts

@@ -1,4 +1,5 @@
 import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
+import type { ReadIoSnapshotsOptions, ReadIoSnapshotsResult } from '../io-snapshots/fetch';
 import { TasksRunner } from '../tasks-runner/tasks-runner';
 import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
 export declare class NxCloudEnterpriseOutdatedError extends Error {
@@ -12,6 +13,8 @@ export interface NxCloudClient {
     commands: Record<string, () => Promise<void>>;
     nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
     getRemoteCache: () => RemoteCacheV2;
+    /** Clients that expose I/O snapshots; see `fetchIoSnapshots`. */
+    readIoSnapshots?: (options: ReadIoSnapshotsOptions) => Promise<ReadIoSnapshotsResult | null>;
 }
 export declare function verifyOrUpdateNxCloudClient(options?: {
     url?: string;

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -1,3 +1,11 @@
-import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
-import { LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+import { DependencyChanges, TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { FileChange, LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../../../config/project-graph';
+import { NxJsonConfiguration } from '../../../../config/nx-json';
+import { PackageJson } from '../../../../utils/package-json';
 export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | LockFileChange>;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, rather than the projects depending on them.
+ */
+export declare function lockFileDependencyChanges(fileChanges: FileChange<WholeFileChange | LockFileChange>[], projectGraphNodes: Record<string, ProjectGraphProjectNode>, nxJson: NxJsonConfiguration, packageJson: PackageJson | undefined, projectGraph: ProjectGraph): DependencyChanges;

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromLockFile = void 0;
+exports.lockFileDependencyChanges = lockFileDependencyChanges;
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const config_1 = require("../../utils/config");
 const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
@@ -9,61 +10,82 @@ const output_1 = require("../../../../utils/output");
 const lock_file_1 = require("../../lock-file/lock-file");
 const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) => {
     const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
-    const changedLockFile = fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
+    const changedLockFile = findChangedLockFile(fileChanges);
+    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
     if (projectsAffectedByDependencyUpdates === 'auto') {
-        return getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson);
+        if (!changedLockFile) {
+            return [];
+        }
+        // External node names, which the reverse walk in filterAffected carries
+        // back to the projects depending on them.
+        return (changedExternalNodes(changedLockFile, projectGraph, packageJson) ??
+            allProjectNames);
     }
     else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
         return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
     }
-    if (changedLockFile) {
-        return Object.values(projectGraphNodes).map((p) => p.name);
-    }
-    return [];
+    return changedLockFile ? allProjectNames : [];
 };
 exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;
 /**
- * In auto mode, parse the lock file at the base and head revisions
- * using Nx's existing lock file parsers, then diff the resulting
- * external-node maps to determine which packages actually changed.
- *
- * Returns external node names (e.g. "npm:lodash@4.17.21") so the
- * graph reversal in filterAffected can walk back to workspace projects.
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, rather than the projects depending on them.
  */
-function getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson) {
-    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
+function lockFileDependencyChanges(fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) {
+    const none = {
+        externals: [],
+        changedExternalTypes: [],
+        projects: [],
+    };
+    const changedLockFile = findChangedLockFile(fileChanges);
     if (!changedLockFile) {
-        return [];
+        return none;
+    }
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    if (Array.isArray(projectsAffectedByDependencyUpdates)) {
+        return {
+            ...none,
+            projects: (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes),
+        };
     }
+    const externals = projectsAffectedByDependencyUpdates === 'auto'
+        ? changedExternalNodes(changedLockFile, projectGraph, packageJson)
+        : null;
+    return externals
+        ? { ...none, externals }
+        : { ...none, changedExternalTypes: ['npm'] };
+}
+function findChangedLockFile(fileChanges) {
+    return fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
+}
+/**
+ * Diffs the lock file's base and head revisions with the parsers the project
+ * graph is built from, and names the external nodes whose package changed.
+ *
+ * Null when the diff cannot be pinned to packages: a WholeFileChange (a
+ * revision could not be read), a parse failure, or a changed package with no
+ * external node in the head graph.
+ */
+function changedExternalNodes(changedLockFile, projectGraph, packageJson) {
     const changes = changedLockFile.getChanges();
-    // A WholeFileChange means we were unable to read both revisions of
-    // the lock file (e.g. missing base revision, git error). Fall back
-    // to marking all projects affected.
     if (!changes.every(file_utils_1.isLockFileChange)) {
-        return allProjectNames;
+        return null;
     }
     const changedPackageNames = getChangedPackageNames(changedLockFile.file, changes, packageJson);
     if (changedPackageNames === null) {
-        return allProjectNames;
+        return null;
     }
     if (changedPackageNames.size === 0) {
         return [];
     }
-    // Look up the changed packages in the project graph's external nodes
-    // and return the external node names. The graph reversal in
-    // filterAffected walks from these nodes to workspace projects.
     const { touchedNodeNames, missingPackageNames } = findExternalNodesByPackageName(changedPackageNames, projectGraph.externalNodes ?? {});
-    if (missingPackageNames.size > 0) {
-        return allProjectNames;
-    }
-    return touchedNodeNames;
+    return missingPackageNames.size > 0 ? null : touchedNodeNames;
 }
 /**
  * Parse the base and head revisions of the lock file with Nx's
  * existing parsers and diff the resulting package -> version maps.
  *
- * Returns the set of changed package names, or null if parsing
- * failed (in which case the caller should fall back to all projects).
+ * Returns the set of changed package names, or null if parsing failed.
  */
 function getChangedPackageNames(file, changes, packageJson) {
     try {

package/dist/src/plugins/js/project-graph/affected/npm-packages.d.ts

@@ -1,4 +1,12 @@
-import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { FileChange, WholeFileChange } from '../../../../project-graph/file-utils';
 import { JsonChange } from '../../../../utils/json-diff';
-import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { DependencyChanges, TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { ProjectGraph } from '../../../../config/project-graph';
+import { NxJsonConfiguration } from '../../../../config/nx-json';
 export declare const getTouchedNpmPackages: TouchedProjectLocator<WholeFileChange | JsonChange>;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, and the workspace projects the root
+ * package.json depends on directly.
+ */
+export declare function packageJsonDependencyChanges(touchedFiles: FileChange<WholeFileChange | JsonChange>[], nxJson: NxJsonConfiguration, projectGraph: ProjectGraph): DependencyChanges;

package/dist/src/plugins/js/project-graph/affected/npm-packages.js

@@ -1,11 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedNpmPackages = void 0;
+exports.packageJsonDependencyChanges = packageJsonDependencyChanges;
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const json_diff_1 = require("../../../../utils/json-diff");
 const logger_1 = require("../../../../utils/logger");
 const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
-const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
+const getTouchedNpmPackages = (touchedFiles, _nodes, nxJson, _packageJson, projectGraph) => touchedNpmPackages(touchedFiles, nxJson, projectGraph) ??
+    Object.keys(projectGraph.nodes);
+exports.getTouchedNpmPackages = getTouchedNpmPackages;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, and the workspace projects the root
+ * package.json depends on directly.
+ */
+function packageJsonDependencyChanges(touchedFiles, nxJson, projectGraph) {
+    const touched = touchedNpmPackages(touchedFiles, nxJson, projectGraph);
+    if (touched === null) {
+        return { externals: [], changedExternalTypes: ['npm'], projects: [] };
+    }
+    return {
+        externals: touched.filter((name) => name in projectGraph.externalNodes),
+        changedExternalTypes: [],
+        projects: touched.filter((name) => name in projectGraph.nodes),
+    };
+}
+/**
+ * External nodes and workspace projects the root package.json change names,
+ * or null when it cannot be pinned to them: a removed dependency, a global
+ * package, or an override selector matching nothing in the graph.
+ */
+function touchedNpmPackages(touchedFiles, nxJson, projectGraph) {
     const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
     if (!packageJsonChange)
         return [];
@@ -19,10 +44,8 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
         if ((0, json_diff_1.isJsonChange)(c) &&
             (c.path[0] === 'dependencies' || c.path[0] === 'devDependencies') &&
             c.path.length === 2) {
-            // A package was deleted so mark all workspace projects as touched.
             if (c.type === json_diff_1.JsonDiffType.Deleted) {
-                touched = Object.keys(projectGraph.nodes);
-                break;
+                return null;
             }
             else {
                 let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1]);
@@ -45,7 +68,7 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
                 }
                 if ('packageName' in npmPackage.data) {
                     if (globalPackages.has(npmPackage.data.packageName)) {
-                        return Object.keys(projectGraph.nodes);
+                        return null;
                     }
                 }
             }
@@ -59,13 +82,12 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
                 continue;
             packagesByName ??= groupPackagesByName(npmPackages);
             const matchingNpmPackages = findPackagesForSelector(packageSelector, packagesByName, c.path[0] === 'pnpm');
-            // An unresolved selector can still target a transitive dependency,
-            // so fall back to marking every project affected.
+            // An unresolved selector can still target a transitive dependency.
             if (!matchingNpmPackages.length) {
-                return Object.keys(projectGraph.nodes);
+                return null;
             }
             if (matchingNpmPackages.some((pkg) => globalPackages.has(pkg.data.packageName))) {
-                return Object.keys(projectGraph.nodes);
+                return null;
             }
             touched.push(...matchingNpmPackages.map((pkg) => pkg.name));
         }
@@ -79,8 +101,7 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
         logger_1.logger.warn(`The affected projects might have not been identified properly. The package(s) ${missingTouchedNpmPackages.join(', ')} were not found. Please open an issue in GitHub including the package.json file.`);
     }
     return [...new Set(touched)];
-};
-exports.getTouchedNpmPackages = getTouchedNpmPackages;
+}
 function getPackageSelector(change) {
     if (typeof change.value.lhs !== 'string' &&
         typeof change.value.rhs !== 'string') {

package/dist/src/plugins/package-json/create-nodes.d.ts

@@ -3,7 +3,7 @@ import type { ProjectConfiguration } from '../../config/workspace-json-project-j
 import { PackageJson } from '../../utils/package-json';
 import { PackageManagerCommands } from '../../utils/package-manager';
 import { CreateNodes } from '../../project-graph/plugins';
-import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
+import type { PackageJsonConfigurationCache } from '../../../plugins/package-json';
 export declare const createNodes: CreateNodes;
 export declare function buildPackageJsonPatterns(workspaceRoot: string, readJson: (path: string) => any): PackageJsonPatterns;
 type PackageJsonPatterns = {
@@ -13,7 +13,7 @@ type PackageJsonPatterns = {
     negativeLookup: Record<string, boolean>;
 };
 export declare function buildPackageJsonWorkspacesMatcher(patterns: PackageJsonPatterns): (p: any) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands): {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache | undefined, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands, nxJson?: NxJsonConfiguration): {
     projects: {
         [x: string]: ProjectConfiguration;
     };

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

@@ -22,7 +22,6 @@ const versions_1 = require("../../utils/versions");
 const plugins_1 = require("../../project-graph/plugins");
 const path_2 = require("path");
 const file_hasher_1 = require("../../hasher/file-hasher");
-const package_json_2 = require("../../../plugins/package-json");
 const globPatterns = (0, globs_1.combineGlobPatterns)('package.json', '**/package.json', 'project.json', '**/project.json');
 exports.createNodes = [
     globPatterns,
@@ -38,7 +37,6 @@ exports.createNodes = [
         const isNextToProjectJson = (packageJsonPath) => {
             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);
@@ -47,7 +45,7 @@ exports.createNodes = [
                 // 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, packageManagerCommand);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, undefined, isInPackageManagerWorkspaces, packageManagerCommand, context.nxJsonConfiguration);
         }, packageJsons, _, context);
     },
 ];
@@ -115,16 +113,18 @@ function buildPackageJsonWorkspacesMatcher(patterns) {
         !patterns.negativeLookup[p] &&
         negative.every((m) => m.match(p));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand, nxJson) {
     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)({
-        ...json,
-        root: projectRoot,
-        isInPackageManagerWorkspaces,
-        nxVersion: versions_1.nxVersion,
-    });
-    const cached = cache.get(hash);
+    const hash = cache
+        ? (0, file_hasher_1.hashObject)({
+            ...json,
+            root: projectRoot,
+            isInPackageManagerWorkspaces,
+            nxVersion: versions_1.nxVersion,
+        })
+        : undefined;
+    const cached = cache?.get(hash);
     if (cached) {
         return {
             projects: {
@@ -132,8 +132,8 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
             },
         };
     }
-    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
-    cache.set(hash, project);
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, nxJson ?? (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
+    cache?.set(hash, project);
     return {
         projects: {
             [project.root]: project,

package/dist/src/project-graph/affected/affected-project-graph-models.d.ts

@@ -6,6 +6,20 @@ export interface AffectedProjectGraphContext {
     nxJson: NxJsonConfiguration<any>;
     touchedProjects: string[];
 }
+/**
+ * What a lockfile or package.json change moved, before it is projected onto
+ * projects (the reverse walk) or tasks (matched against each plan's externals).
+ */
+export interface DependencyChanges {
+    /** External node names whose version or integrity moved. */
+    externals: string[];
+    /** Ecosystems whose manifest changed without the change being pinnable to
+     * packages, so every node of that type counts as moved. A locator names the
+     * ecosystem it reads, since a change to one cannot move another's nodes. */
+    changedExternalTypes: string[];
+    /** Workspace projects the change names outright. */
+    projects: string[];
+}
 export interface TouchedProjectLocator<T extends Change = Change> {
     (fileChanges: FileChange<T>[], projectGraphNodes?: Record<string, ProjectGraphProjectNode>, nxJson?: NxJsonConfiguration<any>, packageJson?: any, projectGraph?: ProjectGraph, projectDeletionAffectsAllProjects?: boolean): string[] | Promise<string[]>;
 }

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

@@ -2,27 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterAffected = filterAffected;
 const file_utils_1 = require("../file-utils");
-const workspace_projects_1 = require("./locators/workspace-projects");
-const touched_projects_1 = require("../../plugins/js/project-graph/affected/touched-projects");
 const operators_1 = require("../operators");
 const configuration_1 = require("../../config/configuration");
-const project_glob_changes_1 = require("./locators/project-glob-changes");
+const affected_projects_1 = require("./affected-projects");
 async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.readNxJson)(), packageJson = (0, file_utils_1.readPackageJson)(), projectDeletionAffectsAllProjects = true) {
-    // Additional affected logic should be in this array.
-    const touchedProjectLocators = [
-        workspace_projects_1.getTouchedProjects,
-        workspace_projects_1.getImplicitlyTouchedProjects,
-        project_glob_changes_1.getTouchedProjectsFromProjectGlobChanges,
-        touched_projects_1.getTouchedProjects,
-    ];
-    const touchedProjects = [];
-    for (const locator of touchedProjectLocators) {
-        performance.mark(locator.name + ':start');
-        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph, projectDeletionAffectsAllProjects);
-        performance.mark(locator.name + ':end');
-        performance.measure(locator.name, locator.name + ':start', locator.name + ':end');
-        touchedProjects.push(...projects);
-    }
+    performance.mark('locateTouchedProjects:start');
+    const touchedProjects = await (0, affected_projects_1.runTouchedProjectLocators)(graph, touchedFiles, nxJson, packageJson, projectDeletionAffectsAllProjects);
+    performance.mark('locateTouchedProjects:end');
+    performance.measure('locateTouchedProjects', 'locateTouchedProjects:start', 'locateTouchedProjects:end');
     return filterAffectedProjects(graph, {
         projectGraphNodes: graph.nodes,
         nxJson,

package/dist/src/project-graph/affected/affected-projects.d.ts

@@ -0,0 +1,7 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+import { FileChange } from '../file-utils';
+/** Runs every locator and returns what each one marked, duplicates included. */
+export declare function runTouchedProjectLocators(graph: ProjectGraph, touchedFiles: FileChange[], nxJson: NxJsonConfiguration, packageJson?: any, projectDeletionAffectsAllProjects?: boolean): Promise<string[]>;
+/** Resolved here because the native side takes the patterns, not the plugins. */
+export declare function getProjectGlobPatterns(nxJson: NxJsonConfiguration): Promise<string[]>;

package/dist/src/project-graph/affected/affected-projects.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTouchedProjectLocators = runTouchedProjectLocators;
+exports.getProjectGlobPatterns = getProjectGlobPatterns;
+const native_1 = require("../../native");
+const get_plugins_1 = require("../plugins/get-plugins");
+const workspace_root_1 = require("../../utils/workspace-root");
+const file_utils_1 = require("../file-utils");
+const touched_projects_1 = require("../../plugins/js/project-graph/affected/touched-projects");
+const transform_objects_1 = require("../../native/transform-objects");
+/** Runs every locator and returns what each one marked, duplicates included. */
+async function runTouchedProjectLocators(graph, touchedFiles, nxJson, packageJson, projectDeletionAffectsAllProjects = true) {
+    return (0, native_1.locateTouchedProjects)((0, transform_objects_1.transformProjectGraphForLocators)(graph), nxJson, touchedFiles.map((f) => f.file), {
+        // Only a deletion reaches projects_from_project_glob_changes, and
+        // resolving the patterns can fall back to starting plugin workers.
+        projectGlobPatterns: touchedFiles.some((f) => (0, file_utils_1.isDeletedFile)(f.file))
+            ? await getProjectGlobPatterns(nxJson)
+            : [],
+        projectDeletionAffectsAllProjects,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    }, 
+    // Takes only paths, so the closure carries the FileChange objects: their
+    // lazy getChanges() cannot cross the native boundary.
+    [
+        async () => (0, touched_projects_1.getTouchedProjects)(touchedFiles, graph.nodes, nxJson, packageJson, graph, projectDeletionAffectsAllProjects),
+    ]);
+}
+/** Resolved here because the native side takes the patterns, not the plugins. */
+async function getProjectGlobPatterns(nxJson) {
+    if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+        return [
+            '**/package.json',
+            '**/project.json',
+            'project.json',
+            'package.json',
+        ];
+    }
+    const capabilities = await (0, get_plugins_1.capabilitiesOfConfiguredPlugins)(nxJson, workspace_root_1.workspaceRoot);
+    return capabilities
+        .map((capability) => capability.createNodesPattern)
+        .filter((pattern) => !!pattern);
+}

package/dist/src/project-graph/affected/affected-tasks.d.ts

@@ -0,0 +1,90 @@
+import { NxJsonConfiguration, TargetDependencies } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+import { TaskGraph } from '../../config/task-graph';
+import { type IoSnapshots } from '../../native';
+import { type IoSnapshotOutcome } from '../../io-snapshots/store';
+import type { IoSnapshotVersion } from '../../daemon/message-types/io-snapshot-version';
+import { FileChange } from '../file-utils';
+import type { NxArgs } from '../../utils/command-line-utils';
+import { TaskPlanningContext } from '../../hasher/task-planning-context';
+import type { TaskSelection } from '../../tasks-runner/run-command';
+/**
+ * Whether `nx affected` selects the individual tasks whose inputs a change
+ * reaches, rather than whole projects. Off by default while the task path
+ * settles.
+ *
+ * Env-var only, so `nx show projects --affected` and `nx affected` in one CI
+ * script agree. The run also executes the selected tasks' dependencies.
+ */
+export declare function selectsAffectedTasks(): boolean;
+export interface AffectedTasksResult {
+    /** The graph selection ran against, which the command should run with too. */
+    projectGraph: ProjectGraph;
+    /** Tasks that are themselves affected — NOT their dependency closure. */
+    affectedTaskIds: Set<string>;
+    /** The full, unpruned graph the answer was computed over. */
+    taskGraph: TaskGraph;
+    /** What the run executes: the affected tasks and what they depend on. */
+    taskSelection: TaskSelection;
+}
+export interface ComputeAffectedTasksOptions {
+    /** Fetched when absent. Unused when the daemon selects; it returns its own graph. */
+    projectGraph?: ProjectGraph;
+    nxJson: NxJsonConfiguration;
+    targets: string[];
+    touchedFiles: FileChange[];
+    /** What `touchedFiles` was computed from, so the daemon reads the same diff. */
+    fileChangeArgs?: FileChangeArgs;
+    configuration?: string;
+    overrides?: Record<string, unknown>;
+    extraTargetDependencies?: TargetDependencies;
+    excludeTaskDependencies?: boolean;
+    /** `--exclude` project patterns. Their tasks leave the selection but still carry a change and run as dependencies. */
+    exclude?: string[];
+    packageJson?: any;
+    /** This command's I/O snapshot set. Selection plans with it, as the run hashes with it. */
+    ioSnapshotOutcome?: IoSnapshotOutcome | null;
+    selectivelyHashTsConfig?: boolean;
+}
+export type FileChangeArgs = Pick<NxArgs, 'base' | 'head' | 'files'>;
+/**
+ * What selection needs from the command, reduced to plain data so the daemon
+ * can run it. Anything read against the project graph, like `--exclude` and the
+ * lockfile diff, is resolved by whichever process selects.
+ */
+export interface AffectedTasksRequest {
+    targets: string[];
+    changedFiles: string[];
+    fileChangeArgs?: FileChangeArgs;
+    configuration?: string;
+    overrides: Record<string, unknown>;
+    extraTargetDependencies: TargetDependencies;
+    excludeTaskDependencies: boolean;
+    exclude: string[];
+    ioSnapshots?: IoSnapshotVersion;
+    /** The runner's `selectivelyHashTsConfig`, which decides what the tsconfig hash reads. */
+    selectivelyHashTsConfig?: boolean;
+}
+/**
+ * Selects the tasks a change reaches, rather than the projects that own a
+ * changed file.
+ *
+ * With the daemon on, the daemon selects: it hashes the run's tasks, so its
+ * planner is the one that remembers the plans. It returns the graph it selected
+ * against, which the command must run with.
+ */
+export declare function computeAffectedTasks(opts: ComputeAffectedTasksOptions): Promise<AffectedTasksResult>;
+/**
+ * Plans the targets' full task graph and matches the changed paths against
+ * every plan. No project-level prefilter: under an I/O snapshot a task can read
+ * files no affected project owns. Shared by the client and the daemon.
+ */
+export declare function selectAffectedTasks(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, planningContext: TaskPlanningContext, request: AffectedTasksRequest, { touchedFiles, packageJson, ioSnapshots, }?: {
+    touchedFiles?: FileChange[];
+    packageJson?: any;
+    ioSnapshots?: IoSnapshots;
+}): Promise<{
+    affectedTaskIds: Set<string>;
+    taskGraph: TaskGraph;
+    taskSelection: TaskSelection;
+}>;