nx 23.3.0-beta.5 → 23.3.0-beta.6

package/dist/nx-cloud-internals.d.ts

@@ -0,0 +1 @@
+export { importIoSnapshots, openIoSnapshots } from './src/io-snapshots/store';

package/dist/nx-cloud-internals.js

@@ -0,0 +1,9 @@
+"use strict";
+// Nx internals for the Nx Cloud client, loaded as `nx/nx-cloud-internals`; not
+// a public API. The client probes these exports to tell what this nx supports,
+// so keep them stable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openIoSnapshots = exports.importIoSnapshots = void 0;
+var store_1 = require("./src/io-snapshots/store");
+Object.defineProperty(exports, "importIoSnapshots", { enumerable: true, get: function () { return store_1.importIoSnapshots; } });
+Object.defineProperty(exports, "openIoSnapshots", { enumerable: true, get: function () { return store_1.openIoSnapshots; } });

package/dist/src/command-line/affected/affected.js

@@ -14,6 +14,7 @@ const affected_project_graph_1 = require("../../project-graph/affected/affected-
 const configuration_1 = require("../../config/configuration");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const graph_1 = require("../graph/graph");
+const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
 async function affected(command, args, extraTargetDependencies = {}, extraOptions = {
     excludeTaskDependencies: args.excludeTaskDependencies,
     loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
@@ -25,16 +26,47 @@ async function affected(command, args, extraTargetDependencies = {}, extraOption
         printWarnings: command !== 'print-affected' && !args.plain && args.graph !== 'stdout',
     }, nxJson);
     await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({
-        exitOnError: true,
-    });
-    const projects = await getAffectedGraphNodes(nxArgs, projectGraph);
+    // Task selection needs a target to select against, so `nx graph --affected`
+    // and the deprecated print-affected stay project-grained.
+    const useTasks = (0, affected_tasks_1.selectsAffectedTasks)() &&
+        command === 'affected' &&
+        !!nxArgs.targets?.length;
+    // Outside the try so errors reach handleErrors, as they did from inside runCommand.
+    let projectGraph;
+    let taskSelection;
+    let projects = [];
+    if (useTasks) {
+        ({ projectGraph, taskSelection } = await (0, affected_tasks_1.computeAffectedTasks)({
+            nxJson,
+            targets: nxArgs.targets,
+            touchedFiles: (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, nxArgs),
+            fileChangeArgs: {
+                base: nxArgs.base,
+                head: nxArgs.head,
+                files: nxArgs.files,
+            },
+            configuration: nxArgs.configuration,
+            overrides,
+            extraTargetDependencies,
+            excludeTaskDependencies: extraOptions.excludeTaskDependencies,
+            exclude: nxArgs.exclude,
+            ...(await (0, run_command_1.runnerInputsForSelection)(nxArgs, nxJson)),
+        }));
+    }
+    else {
+        projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        projects = await getAffectedGraphNodes(nxArgs, projectGraph);
+        if (command === 'affected' && !nxArgs.graph) {
+            taskSelection = (0, run_command_1.selectTasksForProjects)(projectGraph, projectsWithTarget(projects, nxArgs), nxArgs, overrides, extraTargetDependencies, extraOptions.excludeTaskDependencies);
+        }
+    }
     try {
         switch (command) {
             case 'affected': {
-                const projectsWithTarget = allProjectsWithTarget(projects, nxArgs);
                 if (nxArgs.graph) {
-                    const projectNames = projectsWithTarget.map((t) => t.name);
+                    const projectNames = useTasks
+                        ? initiatingProjects(taskSelection)
+                        : projectsWithTarget(projects, nxArgs);
                     const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
                     return await (0, graph_1.generateGraph)({
                         watch: true,
@@ -45,10 +77,13 @@ async function affected(command, args, extraTargetDependencies = {}, extraOption
                             (!nxArgs.projects || nxArgs.projects.length === 0),
                         projects: projectNames,
                         file,
+                        taskSelection: taskSelection ??
+                            (() => (0, run_command_1.selectTasksForProjects)(projectGraph, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions.excludeTaskDependencies)),
+                        configuration: nxArgs.configuration,
                     }, projectNames);
                 }
                 else {
-                    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+                    const status = await (0, run_command_1.runCommand)(taskSelection, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
                     await output_1.output.drain();
                     process.exit(status);
                 }
@@ -74,8 +109,15 @@ async function getAffectedGraphNodes(nxArgs, projectGraph) {
     }
     return Object.values(affectedGraph.nodes);
 }
-function allProjectsWithTarget(projects, nxArgs) {
-    return projects.filter((p) => nxArgs.targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(p, target)));
+function initiatingProjects(selection) {
+    return [
+        ...new Set(selection.initiatingTaskIds.map((id) => selection.taskGraph.tasks[id].target.project)),
+    ];
+}
+function projectsWithTarget(projects, nxArgs) {
+    return projects
+        .filter((p) => nxArgs.targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(p, target)))
+        .map((p) => p.name);
 }
 function printError(e, verbose) {
     const bodyLines = [e.message];

package/dist/src/command-line/graph/graph.d.ts

@@ -1,5 +1,6 @@
 import { ProjectFileMap, ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode } from '../../config/project-graph';
 import { TaskGraph } from '../../config/task-graph';
+import { type TaskSelection } from '../../tasks-runner/run-command';
 export interface GraphError {
     message: string;
     stack: string;
@@ -49,7 +50,37 @@ export declare function generateGraph(args: {
     focus?: string;
     exclude?: string[];
     affected?: boolean;
+    /**
+     * What the command would run for `targets`, or how to build it. A builder
+     * is only called where an output needs it, so the live graph can still
+     * open, and show the error, when the task graph cannot be built.
+     */
+    taskSelection?: TaskSelection | (() => TaskSelection);
+    /** The `-c` the tasks run with; their ids carry it. */
+    configuration?: string;
 }, affectedProjects: string[]): Promise<void>;
+export interface TaskSelectionForGraph {
+    targets: string[];
+    configuration?: string;
+    taskIds: string[];
+}
+/**
+ * The selection applies only to a page asking for its exact targets with its configuration
+ * or none (the ids carry it); anything else would prune to nothing, so it is shown whole.
+ */
+export declare function selectedFor(targets: string[], configuration: string | undefined, selection: TaskSelectionForGraph | undefined): {
+    configuration?: string;
+    taskIds?: string[];
+};
+/**
+ * The task graph to draw: the selection's own when it has one, otherwise built
+ * and, given ids, pruned to them. The live graph rebuilds per request, so it
+ * passes only ids.
+ */
+export declare function taskGraphForSelection(build: () => TaskGraph, selection?: {
+    taskGraph?: TaskGraph;
+    taskIds?: string[];
+}): TaskGraph;
 export declare function getExpandedTaskInputs(depGraphClientResponse: ProjectGraphClientResponse, expandedTaskInputsCache: Map<string, Record<string, string[]>>, taskId: string): Promise<Record<string, string[]>>;
 /**
  * The data type that `nx graph --file graph.json` or `nx build --graph graph.json` contains

package/dist/src/command-line/graph/graph.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateGraph = generateGraph;
+exports.selectedFor = selectedFor;
+exports.taskGraphForSelection = taskGraphForSelection;
 exports.getExpandedTaskInputs = getExpandedTaskInputs;
 const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
@@ -22,6 +24,9 @@ const typescript_1 = require("../../plugins/js/utils/typescript");
 const operators_1 = require("../../project-graph/operators");
 const project_graph_1 = require("../../project-graph/project-graph");
 const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
+const utils_1 = require("../../tasks-runner/utils");
+const run_command_1 = require("../../tasks-runner/run-command");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
 const all_file_data_1 = require("../../utils/all-file-data");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 const native_1 = require("../../native");
@@ -178,6 +183,17 @@ async function generateGraph(args, affectedProjects) {
         }
     }
     let prunedGraph = (0, operators_1.pruneExternalNodes)(rawGraph);
+    // `nx graph --targets` has no command to take a selection from, so it draws
+    // the projects' targets.
+    const jsonTaskSelection = () => args.targets?.length
+        ? (resolveSelection(args.taskSelection) ??
+            (0, run_command_1.selectTasksForProjects)(rawGraph, args.projects?.length
+                ? args.projects
+                : [...(0, project_graph_utils_1.runnableForTarget)(rawGraph.nodes, args.targets)], {
+                targets: args.targets,
+                configuration: args.configuration,
+            }, {}, {}, false))
+        : undefined;
     const projects = Object.values(prunedGraph.nodes);
     projects.sort((a, b) => {
         return a.name.localeCompare(b.name);
@@ -231,7 +247,7 @@ async function generateGraph(args, affectedProjects) {
     let html = (0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '../../core/graph/index.html'), 'utf-8');
     prunedGraph = filterGraph(prunedGraph, args.focus || null, excludePatterns);
     if (args.print || args.file === 'stdout') {
-        console.log(JSON.stringify(await createJsonOutput(prunedGraph, rawGraph, args.projects, args.targets), null, 2));
+        console.log(JSON.stringify(await createJsonOutput(prunedGraph, rawGraph, jsonTaskSelection()), null, 2));
         await output_1.output.drain();
         await new Promise((res) => setImmediate(res));
         process.exit(0);
@@ -258,7 +274,7 @@ async function generateGraph(args, affectedProjects) {
             });
             const { projectGraphClientResponse } = await createProjectGraphAndSourceMapClientResponse(affectedProjects);
             const taskGraphClientResponse = args.targets
-                ? await createTaskGraphForTargetsAndProjects(args.targets, args.projects)
+                ? await createTaskGraphForTargetsAndProjects(args.targets, args.projects, args.configuration, args.taskSelection)
                 : await createTaskGraphClientResponse();
             const taskInputsReponse = await createExpandedTaskInputResponse(taskGraphClientResponse, projectGraphClientResponse);
             const environmentJs = buildEnvironmentJs(excludePatterns, args.watch, !!args.file && args.file.endsWith('html') ? 'build' : 'serve', projectGraphClientResponse, taskGraphClientResponse, taskInputsReponse, sourceMaps);
@@ -275,7 +291,7 @@ async function generateGraph(args, affectedProjects) {
         }
         else if (ext === '.json') {
             (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(fullFilePath), { recursive: true });
-            const json = await createJsonOutput(prunedGraph, rawGraph, args.projects, args.targets);
+            const json = await createJsonOutput(prunedGraph, rawGraph, jsonTaskSelection());
             (0, fileutils_1.writeJsonFile)(fullFilePath, json);
             output_1.output.success({
                 title: `JSON output created in ${fileFolderPath}`,
@@ -297,7 +313,13 @@ async function generateGraph(args, affectedProjects) {
         let app;
         let url;
         try {
-            const result = await startServer(html, environmentJs, args.host || '127.0.0.1', args.port || 4211, args.watch, affectedProjects, args.focus, args.groupByFolder, excludePatterns);
+            const result = await startServer(html, environmentJs, args.host || '127.0.0.1', args.port || 4211, args.watch, affectedProjects, args.focus, args.groupByFolder, excludePatterns, typeof args.taskSelection === 'object' && args.taskSelection.taskIds
+                ? {
+                    targets: args.targets,
+                    configuration: args.configuration,
+                    taskIds: args.taskSelection.taskIds,
+                }
+                : undefined);
             app = result.app;
             url = result.url;
         }
@@ -383,7 +405,7 @@ function findAvailablePort(startPort, host = '127.0.0.1') {
         });
     });
 }
-async function startServer(html, environmentJs, host, port = 4211, watchForChanges = true, affected = [], focus = null, groupByFolder = false, exclude = []) {
+async function startServer(html, environmentJs, host, port = 4211, watchForChanges = true, affected = [], focus = null, groupByFolder = false, exclude = [], selection) {
     let unregisterFileWatcher;
     if (watchForChanges && !client_1.daemonClient.enabled()) {
         output_1.output.warn({
@@ -427,14 +449,15 @@ async function startServer(html, environmentJs, host, port = 4211, watchForChang
         if (sanitizePath === 'task-graph.json') {
             const projectsParam = parsedUrl.searchParams.get('projects');
             const targetsParam = parsedUrl.searchParams.get('targets');
-            const configuration = parsedUrl.searchParams.get('configuration');
+            const configuration = parsedUrl.searchParams.get('configuration') || undefined;
             res.writeHead(200, { 'Content-Type': 'application/json' });
             if (targetsParam) {
                 const targetNames = targetsParam.split(' ').filter(Boolean);
                 const projectNames = projectsParam
                     ? projectsParam.split(' ').filter(Boolean)
                     : undefined;
-                return res.end(JSON.stringify(await createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration)));
+                const request = selectedFor(targetNames, configuration, selection);
+                return res.end(JSON.stringify(await createTaskGraphForTargetsAndProjects(targetNames, projectNames, request.configuration, { taskIds: request.taskIds })));
             }
             // load all task graphs if there's no targets specified
             return res.end(JSON.stringify(await createTaskGraphClientResponse()));
@@ -726,7 +749,7 @@ async function createTaskGraphClientResponse(pruneExternal = false) {
     try {
         const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, {}, projects, targets, undefined, {});
         node_perf_hooks_1.performance.mark('task graph generation:end');
-        const planner = new native_1.HashPlanner(nxJson, (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(graph)));
+        const planner = new native_1.HashPlanner(nxJson, (0, transform_objects_1.transformProjectGraphForRust)(graph));
         node_perf_hooks_1.performance.mark('task hash plan generation:start');
         const taskIds = Object.keys(taskGraph.tasks);
         const plans = taskIds.length > 0 ? planner.getPlans(taskIds, taskGraph) : {};
@@ -774,10 +797,40 @@ function clearTaskGraphCache() {
     expandedTaskInputsCache.clear();
 }
 /**
- * Creates a single task graph for multiple projects with multiple targets
- * If no projects specified, returns graph for all projects with the targets
+ * The selection applies only to a page asking for its exact targets with its configuration
+ * or none (the ids carry it); anything else would prune to nothing, so it is shown whole.
+ */
+function selectedFor(targets, configuration, selection) {
+    const applies = selection &&
+        targets.length === selection.targets.length &&
+        targets.every((target) => selection.targets.includes(target)) &&
+        (configuration === undefined || configuration === selection.configuration);
+    return applies
+        ? { configuration: selection.configuration, taskIds: selection.taskIds }
+        : { configuration };
+}
+function resolveSelection(selection) {
+    return typeof selection === 'function' ? selection() : selection;
+}
+/**
+ * The task graph to draw: the selection's own when it has one, otherwise built
+ * and, given ids, pruned to them. The live graph rebuilds per request, so it
+ * passes only ids.
+ */
+function taskGraphForSelection(build, selection) {
+    if (selection?.taskGraph) {
+        return selection.taskGraph;
+    }
+    const taskGraph = build();
+    return selection?.taskIds
+        ? (0, utils_1.pruneToSelectedTasks)(taskGraph, selection.taskIds)
+        : taskGraph;
+}
+/**
+ * The task graph client response for `targetNames`: `selection`'s graph when given,
+ * else built for `projectNames` (default: every project with one of the targets).
  */
-async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration) {
+async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration, selection) {
     // Get project graph
     let graph;
     try {
@@ -801,10 +854,11 @@ async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, c
             .map(([projectName]) => projectName);
     }
     try {
-        // Create single task graph
-        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, {}, projectsToUse, targetNames, configuration, {});
+        const taskGraph = taskGraphForSelection(() => (0, create_task_graph_1.createTaskGraph)(graph, {}, projectsToUse, targetNames, configuration, {}), 
+        // Built in here, so an error is reported in the page like any other.
+        resolveSelection(selection));
         node_perf_hooks_1.performance.mark(`task graph generation:end`);
-        const planner = new native_1.HashPlanner(nxJson, (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(graph)));
+        const planner = new native_1.HashPlanner(nxJson, (0, transform_objects_1.transformProjectGraphForRust)(graph));
         node_perf_hooks_1.performance.mark('task hash plan generation:start');
         const taskIds = Object.keys(taskGraph.tasks);
         const plans = taskIds.length > 0 ? planner.getPlans(taskIds, taskGraph) : {};
@@ -982,12 +1036,12 @@ function getExpandedWorkspaceRoots(workspaceRootInputs, allWorkspaceFiles) {
     workspaceRootsExpanded.sort();
     return workspaceRootsExpanded;
 }
-async function createJsonOutput(prunedGraph, rawGraph, projects, targets) {
+async function createJsonOutput(prunedGraph, rawGraph, taskSelection) {
     const response = {
         graph: prunedGraph,
     };
-    if (targets?.length) {
-        const taskGraph = (0, create_task_graph_1.createTaskGraph)(rawGraph, {}, projects, targets, undefined, {});
+    if (taskSelection) {
+        const taskGraph = taskSelection.taskGraph;
         const hasher = (0, create_task_hasher_1.createTaskHasher)(rawGraph, (0, configuration_1.readNxJson)());
         let tasks = Object.values(taskGraph.tasks);
         // Match the runtime path: each task is hashed against its own env so

package/dist/src/command-line/release/publish.js

@@ -181,6 +181,7 @@ async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, ex
             targets: [requiredTargetName],
             projects: projectNamesWithTarget,
             file,
+            taskSelection: () => (0, run_command_1.selectTasksForProjects)(projectGraph, projectNamesWithTarget, { targets: [requiredTargetName] }, overrides, {}, extraOptions.excludeTaskDependencies),
         }, projectNamesWithTarget);
         return {};
     }
@@ -208,24 +209,19 @@ async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, ex
      */
     process.env.NX_TUI = 'false';
     const publishOutputStyle = args.specifiedOutputStyle ?? 'static';
-    const { taskResults } = await (0, run_command_1.runCommandForTasks)(projectsWithTarget, projectGraph, { nxJson }, {
+    const publishArgs = {
         targets: [requiredTargetName],
         ...args,
-        // Everything this command reports — the registry, the tag, the
-        // package.json diff, the dry-run summary — is printed from inside the
-        // task, so the failures-only default would swallow all of it (under
-        // --dry-run every task succeeds by definition). Set after the spread and
-        // on all three fields: the middleware always writes `resolvedOutputStyle`,
-        // so a value placed before it would be overwritten on every run, and the
-        // renderer reads the new fields rather than the deprecated one. A style
-        // the user actually named still wins, which is what `specifiedOutputStyle`
-        // being set means.
+        // All output is printed from inside the task, so the failures-only default
+        // would hide it. Set after the spread, on all three fields: the middleware
+        // always writes `resolvedOutputStyle`.
         outputStyle: publishOutputStyle,
         specifiedOutputStyle: publishOutputStyle,
         resolvedOutputStyle: publishOutputStyle,
         // It is possible for workspaces to have circular dependencies between packages and still release them to a registry
         nxIgnoreCycles: true,
-    }, overrides, null, {}, extraOptions);
+    };
+    const { taskResults } = await (0, run_command_1.runTasksForCommand)((0, run_command_1.selectTasksForProjects)(projectGraph, projectsWithTarget.map((p) => p.name), publishArgs, overrides, {}, extraOptions.excludeTaskDependencies), projectGraph, { nxJson }, publishArgs, overrides, null, {}, extraOptions);
     const endTime = Date.now();
     const publishProjectsResult = {};
     for (const taskData of Object.values(taskResults)) {

package/dist/src/command-line/release/utils/get-touched-projects-for-group.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGetTouchedProjectsForGroup = createGetTouchedProjectsForGroup;
-const workspace_projects_1 = require("../../../project-graph/affected/locators/workspace-projects");
+const native_1 = require("../../../native");
+const transform_objects_1 = require("../../../native/transform-objects");
 const file_utils_1 = require("../../../project-graph/file-utils");
 const ignore_1 = require("../../../utils/ignore");
 const output_1 = require("../../../utils/output");
@@ -44,8 +45,7 @@ function createGetTouchedProjectsForGroup(nxArgs, projectGraph, changedFiles, fi
             touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
         }
         else {
-            // We only care about directly touched projects, not implicitly affected ones etc
-            const touchedProjectsArr = await (0, workspace_projects_1.getTouchedProjects)((0, file_utils_1.calculateFileChanges)(changedFiles, nxArgs, undefined, ignore), projectGraph.nodes);
+            const touchedProjectsArr = (0, native_1.directlyTouchedProjects)((0, transform_objects_1.transformProjectGraphForLocators)(projectGraph), (0, file_utils_1.calculateFileChanges)(changedFiles, nxArgs, undefined, ignore).map((f) => f.file));
             touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
             serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
         }

package/dist/src/command-line/run/run-one.js

@@ -37,6 +37,8 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
         process.exit(0);
     }
     await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    // --graph's file output draws this selection; the live graph builds its own.
+    const selectTasks = () => (0, run_command_1.selectTasksForProjects)(projectGraph, projects.map((p) => p.name), nxArgs, overrides, extraTargetDependencies, extraOptions.excludeTaskDependencies);
     if (nxArgs.graph) {
         const projectNames = projects.map((t) => t.name);
         const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
@@ -47,10 +49,12 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
             targets: nxArgs.targets,
             projects: projectNames,
             file,
+            taskSelection: selectTasks,
+            configuration: nxArgs.configuration,
         }, projectNames);
     }
     else {
-        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
+        const status = await (0, run_command_1.runCommand)(selectTasks(), projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
         await output_1.output.drain();
         process.exit(status);
     }

package/dist/src/command-line/run-many/run-many.js

@@ -26,6 +26,8 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = {
     await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
     const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
     const projects = projectsToRun(nxArgs, projectGraph);
+    // --graph's file output draws this selection; the live graph builds its own.
+    const selectTasks = () => (0, run_command_1.selectTasksForProjects)(projectGraph, projects.map((p) => p.name), nxArgs, overrides, extraTargetDependencies, extraOptions.excludeTaskDependencies);
     if (nxArgs.graph) {
         const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
         const projectNames = projects.map((t) => t.name);
@@ -37,17 +39,19 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = {
             targets: nxArgs.targets,
             projects: projectNames,
             file,
+            taskSelection: selectTasks,
+            configuration: nxArgs.configuration,
         }, projectNames);
     }
     else {
-        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        const status = await (0, run_command_1.runCommand)(selectTasks(), projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
         await output_1.output.drain();
         process.exit(status);
     }
 }
 function projectsToRun(nxArgs, projectGraph) {
     const selectedProjects = {};
-    const validProjects = runnableForTarget(projectGraph.nodes, nxArgs.targets);
+    const validProjects = (0, project_graph_utils_1.runnableForTarget)(projectGraph.nodes, nxArgs.targets);
     const invalidProjects = [];
     // --all is default now, if --projects is provided, it'll override the --all
     if (nxArgs.all && nxArgs.projects.length === 0) {
@@ -78,13 +82,3 @@ function projectsToRun(nxArgs, projectGraph) {
     }
     return Object.values(selectedProjects);
 }
-function runnableForTarget(projects, targets) {
-    const runnable = new Set();
-    for (let projectName in projects) {
-        const project = projects[projectName];
-        if (targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(project, target))) {
-            runnable.add(projectName);
-        }
-    }
-    return runnable;
-}

package/dist/src/command-line/show/projects.js

@@ -4,6 +4,7 @@ exports.showProjectsHandler = showProjectsHandler;
 const output_1 = require("../../utils/output");
 const nx_json_1 = require("../../config/nx-json");
 const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
 const file_utils_1 = require("../../project-graph/file-utils");
 const operators_1 = require("../../project-graph/operators");
 const project_graph_1 = require("../../project-graph/project-graph");
@@ -20,7 +21,31 @@ async function showProjectsHandler(args) {
     // Affected touches dependencies so it needs to be processed first.
     if (args.affected) {
         const touchedFiles = await getTouchedFiles(nxArgs);
-        graph = await getAffectedGraph(touchedFiles, nxJson, graph);
+        // With a target, list projects owning an affected task for it, matching `affected -t`.
+        if ((0, affected_tasks_1.selectsAffectedTasks)() && args.withTarget?.length && !args.projects) {
+            const affectedTasks = await (0, affected_tasks_1.computeAffectedTasks)({
+                projectGraph: graph,
+                nxJson,
+                targets: args.withTarget,
+                touchedFiles,
+                fileChangeArgs: {
+                    base: nxArgs.base,
+                    head: nxArgs.head,
+                    files: nxArgs.files,
+                },
+                ...(await runCommandModule().runnerInputsForSelection(nxArgs, nxJson)),
+            });
+            const { taskGraph, initiatingTaskIds } = affectedTasks.taskSelection;
+            const owning = new Set(initiatingTaskIds.map((id) => taskGraph.tasks[id].target.project));
+            // The graph selection ran against: with the daemon on, the daemon's, not `graph`.
+            graph = {
+                ...affectedTasks.projectGraph,
+                nodes: Object.fromEntries(Object.entries(affectedTasks.projectGraph.nodes).filter(([name]) => owning.has(name))),
+            };
+        }
+        else {
+            graph = await getAffectedGraph(touchedFiles, nxJson, graph);
+        }
     }
     const filter = (0, operators_1.filterNodes)((node) => {
         if (args.type && node.type !== args.type) {
@@ -78,3 +103,7 @@ function getAffectedGraph(touchedFiles, nxJson, graph) {
 async function getTouchedFiles(nxArgs) {
     return (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, nxArgs);
 }
+/** Loaded only when task selection needs it. */
+function runCommandModule() {
+    return require('../../tasks-runner/run-command');
+}

package/dist/src/config/task-graph.d.ts

@@ -3,4 +3,4 @@
  * `packages/nx/src/native/tasks/types.rs` and exposed to TypeScript via NAPI.
  * This file re-exports them so existing imports keep working.
  */
-export type { Task, TaskGraph, TaskTarget, TaskHashDetails } from '../native';
+export type { Task, TaskGraph, TaskTarget, TaskHashDetails, TaskUltracacheConfiguration, } from '../native';

package/dist/src/config/workspace-json-project-json.d.ts

@@ -1,4 +1,4 @@
-import type { JsonInput } from '../native';
+import type { JsonInput, TaskUltracacheConfiguration } from '../native';
 import type { PackageJson } from '../utils/package-json';
 import type { NxJsonConfiguration, NxReleaseDockerConfiguration, NxReleaseVersionConfiguration } from './nx-json';
 /**
@@ -147,6 +147,22 @@ export interface TargetMetadata {
         };
     };
 }
+/**
+ * Authoring form of a property merged key-by-key: permits the `'...'` spread
+ * token alongside the resolved keys. Merging resolves the token, so it never
+ * appears on the resolved shape.
+ */
+export type Spreadable<T> = T & {
+    '...'?: true;
+};
+/**
+ * Ultracache configuration for a target's tasks.
+ *
+ * The resolved shape rides on each Task instance (`Task['ultracache']`), which
+ * is why it is shared with the native task definition. Authoring additionally
+ * permits `'...'`, which target merging resolves away.
+ */
+export type TargetUltracacheConfiguration = Spreadable<TaskUltracacheConfiguration>;
 export interface TargetDependencyConfig {
     /**
      * A list of projects that have `target`.
@@ -244,6 +260,10 @@ export interface TargetConfiguration<T = any> {
      * Determines if Nx is able to cache a given target.
      */
     cache?: boolean;
+    /**
+     * Configures ultracache for tasks of this target. Nx Cloud only.
+     */
+    ultracache?: TargetUltracacheConfiguration;
     /**
      * Metadata about the target
      */