nx 23.1.0 → 23.1.2

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.js

@@ -26,7 +26,6 @@ const workspace_root_1 = require("../../../utils/workspace-root");
 const git_utils_1 = require("../../../utils/git-utils");
 const pc = tslib_1.__importStar(require("picocolors"));
 const ora = require('ora');
-const open = require('open');
 function onlyDefaultRunnerIsUsed(nxJson) {
     const defaultRunner = nxJson.tasksRunnerOptions?.default?.runner;
     if (!defaultRunner) {
@@ -161,6 +160,7 @@ async function runConnectToNxCloud(options, command) {
     try {
         const cloudConnectSpinner = ora(`Opening Nx Cloud ${connectCloudUrl} in your browser to connect your workspace.`).start();
         await sleep(2000);
+        const { default: open } = await new Function('return import("open")')();
         await open(connectCloudUrl);
         cloudConnectSpinner.succeed();
     }

package/dist/src/command-line/nx-cloud/connect/view-logs.js

@@ -39,6 +39,8 @@ async function viewLogs() {
         return 1;
     }
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    // Intentionally not runNxSync: this invokes the separate `nx-cloud` binary,
+    // not the nx CLI that runNxSync resolves.
     (0, child_process_1.execSync)(`${pmc.exec} nx-cloud upload-and-show-run-details`, {
         stdio: [0, 1, 2],
         windowsHide: true,

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

@@ -305,6 +305,11 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             const projectNodes = projects.map((name) => projectGraph.nodes[name]);
             if (releaseGroup.projectsRelationship === 'independent') {
                 for (const project of projectNodes) {
+                    if (!projectsVersionData[project.name] ||
+                        (projectsVersionData[project.name].newVersion === null &&
+                            !projectsVersionData[project.name].dockerVersion)) {
+                        continue;
+                    }
                     let changes = null;
                     if (releaseGroup.resolvedVersionPlans) {
                         changes = (0, version_plan_utils_1.createChangesFromProjectsVersionPlans)(releaseGroup.resolvedVersionPlans, project.name);

package/dist/src/command-line/release/index.d.ts

@@ -46,4 +46,4 @@ export declare const release: typeof defaultClient.release;
 /**
  * @public
  */
-export { AfterAllProjectsVersioned, VersionActions, } from './version/version-actions';
+export { AfterAllProjectsVersioned, ResolveVersionForDependency, VersionActions, } from './version/version-actions';

package/dist/src/command-line/release/utils/git.js

@@ -443,8 +443,10 @@ function extractReferencesFromCommit(commit) {
             references.push({ type: 'issue', value: m[1] });
         }
     }
-    // Extract issue references from commit body
-    for (const m of commit.body.matchAll(IssueRE)) {
+    // Extract issue references from commit body, only when linked via a closing
+    // keyword so that other repos' issue numbers mentioned in prose are not
+    // picked up (e.g. "web-infra-dev/rspack#2292")
+    for (const m of commit.body.matchAll(IssueClosingKeywordRE)) {
         if (!references.some((i) => i.value === m[1])) {
             references.push({ type: 'issue', value: m[1] });
         }
@@ -466,13 +468,15 @@ function getAllAuthorsForCommit(commit) {
 }
 // https://www.conventionalcommits.org/en/v1.0.0/
 // https://regex101.com/r/FSfNvA/1
-const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)/i;
+const ConventionalCommitRegex = /^(?<type>[^\s():!]+)(?:\s*\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)$/u;
 const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gim;
 // GitHub style PR references
 const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
 // GitLab style merge request references
 const GitLabMergeRequestRE = /See merge request (?:[a-z0-9/-]+)?(![\d]+)/gim;
 const IssueRE = /(#\d+)/gm;
+// GitHub style issue closing keywords, e.g. "Fixes #1234"
+const IssueClosingKeywordRE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?):?\s+(#\d+)/gim;
 const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
 const RevertHashRE = /This reverts commit (?<hash>[\da-f]{40})./gm;
 function parseVersionPlanCommit(commit) {

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

@@ -86,8 +86,8 @@ export declare class ReleaseGraph {
         source: string;
         target: string;
         type: string;
-        dependencyCollection: string;
-        rawVersionSpec: string;
+        dependencyCollection: string | null;
+        rawVersionSpec: string | null;
     }[]>;
     readonly releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>;
     private originalFilteredProjects;
@@ -161,6 +161,23 @@ export declare class ReleaseGraph {
      * Resolve current versions for all projects that will be processed
      */
     private resolveCurrentVersionsForProjects;
+    /**
+     * Resolve the current version of a single project via its configured
+     * `currentVersionResolver` (honoring `fallbackCurrentVersionResolver`),
+     * performing the git-tag lookup when applicable.
+     *
+     * Extracted from `resolveCurrentVersionsForProjects` so it can also be
+     * invoked on-demand for projects that are NOT part of `allProjectsToProcess`.
+     */
+    private resolveCurrentVersionForProject;
+    /**
+     * Resolve and cache the current version of a dependency that is not already
+     * being versioned. Ecosystem-specific VersionActions call this lazily when
+     * they need a concrete version that is absent from `dependenciesToUpdate`.
+     *
+     * @internal
+     */
+    resolveCurrentVersionForDependency(tree: Tree, projectGraph: ProjectGraph, projectName: string, preid: string): Promise<string>;
     /**
      * Build dependency relationships between release groups
      */

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

@@ -373,31 +373,79 @@ class ReleaseGraph {
     async resolveCurrentVersionsForProjects(tree, projectGraph, preid) {
         for (const [, releaseGroupNode] of this.groupGraph) {
             for (const projectName of releaseGroupNode.group.projects) {
-                const projectGraphNode = projectGraph.nodes[projectName];
                 if (!this.allProjectsToProcess.has(projectName)) {
                     continue;
                 }
-                const versionActions = this.projectsToVersionActions.get(projectName);
-                const finalConfigForProject = this.finalConfigsByProject.get(projectName);
-                let latestMatchingGitTag;
-                const releaseTagPattern = releaseGroupNode.group.releaseTag.pattern;
-                if (finalConfigForProject.currentVersionResolver === 'git-tag') {
-                    latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
-                        projectName: (0, git_1.sanitizeProjectNameForGitTag)(projectGraphNode.name),
-                        releaseGroupName: releaseGroupNode.group.name,
-                    }, this.resolveRepositoryTags.bind(this), {
-                        checkAllBranchesWhen: releaseGroupNode.group.releaseTag.checkAllBranchesWhen,
-                        preid: preid,
-                        requireSemver: releaseGroupNode.group.releaseTag.requireSemver,
-                        strictPreid: releaseGroupNode.group.releaseTag.strictPreid,
-                    });
-                    this.cachedLatestMatchingGitTag.set(projectName, latestMatchingGitTag);
-                }
-                const currentVersion = await (0, resolve_current_version_1.resolveCurrentVersion)(tree, projectGraphNode, releaseGroupNode.group, versionActions, this.projectLoggers.get(projectName), this.currentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag);
+                const currentVersion = await this.resolveCurrentVersionForProject(tree, projectGraph, releaseGroupNode.group, projectName, preid);
                 this.cachedCurrentVersions.set(projectName, currentVersion);
             }
         }
     }
+    /**
+     * Resolve the current version of a single project via its configured
+     * `currentVersionResolver` (honoring `fallbackCurrentVersionResolver`),
+     * performing the git-tag lookup when applicable.
+     *
+     * Extracted from `resolveCurrentVersionsForProjects` so it can also be
+     * invoked on-demand for projects that are NOT part of `allProjectsToProcess`.
+     */
+    async resolveCurrentVersionForProject(tree, projectGraph, releaseGroup, projectName, preid) {
+        const projectGraphNode = projectGraph.nodes[projectName];
+        const versionActions = this.projectsToVersionActions.get(projectName);
+        const finalConfigForProject = this.finalConfigsByProject.get(projectName);
+        let latestMatchingGitTag;
+        const releaseTagPattern = releaseGroup.releaseTag.pattern;
+        if (finalConfigForProject.currentVersionResolver === 'git-tag') {
+            latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
+                projectName: (0, git_1.sanitizeProjectNameForGitTag)(projectGraphNode.name),
+                releaseGroupName: releaseGroup.name,
+            }, this.resolveRepositoryTags.bind(this), {
+                checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
+                preid: preid,
+                requireSemver: releaseGroup.releaseTag.requireSemver,
+                strictPreid: releaseGroup.releaseTag.strictPreid,
+            });
+            this.cachedLatestMatchingGitTag.set(projectName, latestMatchingGitTag);
+        }
+        return (0, resolve_current_version_1.resolveCurrentVersion)(tree, projectGraphNode, releaseGroup, versionActions, this.projectLoggers.get(projectName), this.currentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag);
+    }
+    /**
+     * Resolve and cache the current version of a dependency that is not already
+     * being versioned. Ecosystem-specific VersionActions call this lazily when
+     * they need a concrete version that is absent from `dependenciesToUpdate`.
+     *
+     * @internal
+     */
+    async resolveCurrentVersionForDependency(tree, projectGraph, projectName, preid) {
+        if (this.cachedCurrentVersions.has(projectName)) {
+            const currentVersion = this.cachedCurrentVersions.get(projectName);
+            if (currentVersion) {
+                return currentVersion;
+            }
+            const currentVersionResolver = this.finalConfigsByProject.get(projectName)?.currentVersionResolver;
+            throw new Error(`Cannot resolve a concrete current version for dependency project "${projectName}" because its "currentVersionResolver" is set to "${currentVersionResolver}" and did not resolve a version. Configure a resolver that can determine the current version.`);
+        }
+        const releaseGroup = this.projectToReleaseGroup.get(projectName);
+        if (!releaseGroup ||
+            !this.projectsToVersionActions.has(projectName) ||
+            !this.finalConfigsByProject.has(projectName)) {
+            throw new Error(`Cannot resolve a concrete current version for dependency project "${projectName}" because it is not configured for Nx Release. Include the project in an Nx Release group so that its current version resolver can be configured.`);
+        }
+        let currentVersion;
+        try {
+            currentVersion = await this.resolveCurrentVersionForProject(tree, projectGraph, releaseGroup, projectName, preid);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            throw new Error(`Cannot resolve a concrete current version for dependency project "${projectName}". ${errorMessage}`);
+        }
+        if (!currentVersion) {
+            const finalConfigForProject = this.finalConfigsByProject.get(projectName);
+            throw new Error(`Cannot resolve a concrete current version for dependency project "${projectName}" because its "currentVersionResolver" is set to "${finalConfigForProject.currentVersionResolver}" and did not resolve a version. Configure a resolver that can determine the current version.`);
+        }
+        this.cachedCurrentVersions.set(projectName, currentVersion);
+        return currentVersion;
+    }
     /**
      * Build dependency relationships between release groups
      */
@@ -662,7 +710,11 @@ Valid values are: ${exports.validReleaseVersionPrefixes
             head: commit.shortHash,
         });
         // Use the same affected detection logic as `nx affected`
-        affectedGraph = await (0, affected_project_graph_1.filterAffected)(projectGraph, touchedFiles);
+        affectedGraph = await (0, affected_project_graph_1.filterAffected)(projectGraph, touchedFiles, undefined, undefined, 
+        // Release evaluates historical commits against the current project
+        // graph. A project configuration which no longer exists must not make
+        // every surviving release project relevant to that commit.
+        false);
         this.affectedGraphPerCommit.set(shortHash, affectedGraph);
         return affectedGraph;
     }

package/dist/src/command-line/release/utils/remote-release-clients/github.js

@@ -104,6 +104,12 @@ class GithubRemoteReleaseClient extends remote_release_client_1.RemoteReleaseCli
         await Promise.all([...authors.keys()].map(async (authorName) => {
             const meta = authors.get(authorName);
             for (const email of meta.email) {
+                // An empty email makes the URL `/users/find/`, so ungh attributes
+                // the commit to the "find" user rather than the real author.
+                // Non-emails just 404, but skip those too to avoid a wasted lookup.
+                if (!email || !email.includes('@')) {
+                    continue;
+                }
                 if (email.endsWith('@users.noreply.github.com')) {
                     const match = email.match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
                     if (match && match[2]) {
@@ -235,7 +241,7 @@ class GithubRemoteReleaseClient extends remote_release_client_1.RemoteReleaseCli
         if (!shouldContinueInGitHub) {
             return;
         }
-        const open = require('open');
+        const { default: open } = await new Function('return import("open")')();
         await open(result.url)
             .then(() => {
             console.info(`\nFollow up in the browser to manually create the release:\n\n` +

package/dist/src/command-line/release/utils/remote-release-clients/gitlab.js

@@ -157,7 +157,7 @@ class GitLabRemoteReleaseClient extends remote_release_client_1.RemoteReleaseCli
         if (!shouldContinueInGitLab) {
             return;
         }
-        const open = require('open');
+        const { default: open } = await new Function('return import("open")')();
         await open(result.url)
             .then(() => {
             console.info(`\nFollow up in the browser to manually create the release:\n\n` +

package/dist/src/command-line/release/utils/shared.d.ts

@@ -24,8 +24,8 @@ export interface VersionDataEntry {
         source: string;
         target: string;
         type: string;
-        dependencyCollection: string;
-        rawVersionSpec: string;
+        dependencyCollection: string | null;
+        rawVersionSpec: string | null;
     }[];
 }
 export declare function isPrerelease(version: string): boolean;

package/dist/src/command-line/release/version/release-group-processor.d.ts

@@ -42,6 +42,21 @@ export declare class ReleaseGroupProcessor {
      * processing them multiple times. Used during the group traversal.
      */
     private processedGroups;
+    /**
+     * Tracks release groups that have completed all version decisions. A group
+     * can reach this state before its dependency manifests are updated.
+     */
+    private groupsWithFinalizedVersionDecisions;
+    /**
+     * Tracks projects whose dependency manifests must wait until all release
+     * groups have completed their version decisions.
+     */
+    private projectsWithDeferredDependencyUpdates;
+    /**
+     * Indicates that every release group has completed its version decisions,
+     * so dependency manifests can use final versions safely.
+     */
+    private allVersionDecisionsFinalized;
     /**
      * Keeps track of which projects have already had their versions bumped.
      * This is used to avoid redundant version bumping and to determine which
@@ -96,6 +111,15 @@ export declare class ReleaseGroupProcessor {
     private getCachedFinalConfigForProject;
     private calculateNewVersion;
     private updateDependenciesForProject;
+    private finalizeVersionDecisionsForGroup;
+    private finalizeAllVersionDecisions;
+    /**
+     * Resolve a dependency version when `dependenciesToUpdate` does not contain
+     * a concrete version for a manifest entry.
+     *
+     * @internal
+     */
+    resolveVersionForDependency(dependencyProjectName: string): Promise<string>;
     private bumpVersionForProject;
     private updateDependenciesForDependents;
     private getOriginalDependentProjects;

package/dist/src/command-line/release/version/release-group-processor.js

@@ -31,6 +31,21 @@ class ReleaseGroupProcessor {
          * processing them multiple times. Used during the group traversal.
          */
         this.processedGroups = new Set();
+        /**
+         * Tracks release groups that have completed all version decisions. A group
+         * can reach this state before its dependency manifests are updated.
+         */
+        this.groupsWithFinalizedVersionDecisions = new Set();
+        /**
+         * Tracks projects whose dependency manifests must wait until all release
+         * groups have completed their version decisions.
+         */
+        this.projectsWithDeferredDependencyUpdates = new Set();
+        /**
+         * Indicates that every release group has completed its version decisions,
+         * so dependency manifests can use final versions safely.
+         */
+        this.allVersionDecisionsFinalized = false;
         /**
          * Keeps track of which projects have already had their versions bumped.
          * This is used to avoid redundant version bumping and to determine which
@@ -120,6 +135,7 @@ class ReleaseGroupProcessor {
             this.processedGroups.add(nextGroup);
             processOrder.push(nextGroup);
         }
+        await this.finalizeAllVersionDecisions(processOrder);
         return processOrder;
     }
     flushAllProjectLoggers() {
@@ -208,11 +224,6 @@ class ReleaseGroupProcessor {
     async processGroup(releaseGroupName) {
         const groupNode = this.releaseGraph.groupGraph.get(releaseGroupName);
         await this.bumpVersions(groupNode.group);
-        // Flush the project loggers for the group
-        for (const project of groupNode.group.projects) {
-            const projectLogger = this.getProjectLoggerForProject(project);
-            projectLogger.flush();
-        }
     }
     async bumpVersions(releaseGroup) {
         if (releaseGroup.projectsRelationship === 'fixed') {
@@ -224,6 +235,7 @@ class ReleaseGroupProcessor {
     }
     async bumpFixedVersionGroup(releaseGroup) {
         if (releaseGroup.projects.length === 0) {
+            this.finalizeVersionDecisionsForGroup(releaseGroup);
             return false;
         }
         let bumped = false;
@@ -287,6 +299,7 @@ class ReleaseGroupProcessor {
                     projectLogger.buffer(`🚫 Skipping versioning for ${project} as it is a part of a fixed release group with ${firstProject} and no dependency bumps were detected`);
                 }
             }
+            this.finalizeVersionDecisionsForGroup(releaseGroup);
             return bumpedByDependency;
         }
         const { newVersion } = await this.calculateNewVersion(firstProject, newVersionInput, newVersionInputReason, newVersionInputReasonData);
@@ -319,6 +332,7 @@ class ReleaseGroupProcessor {
                 dependentProjects: this.getOriginalDependentProjects(project),
             });
         }
+        this.finalizeVersionDecisionsForGroup(releaseGroup);
         // Then, update dependencies for all projects in the fixed group, also in topological order
         if (bumped) {
             for (const project of sortedProjects) {
@@ -359,6 +373,7 @@ class ReleaseGroupProcessor {
                 }
             }
         }
+        this.finalizeVersionDecisionsForGroup(releaseGroup);
         // Third pass: Update dependencies also in topological order
         for (const project of sortedProjects) {
             if (projectsToUpdate.has(project) &&
@@ -472,6 +487,11 @@ class ReleaseGroupProcessor {
         if (!this.releaseGraph.allProjectsToProcess.has(projectName)) {
             throw new Error(`Unable to find ${projectName} in allProjectsToProcess, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
+        if (!this.allVersionDecisionsFinalized) {
+            this.projectsWithDeferredDependencyUpdates.add(projectName);
+            return;
+        }
+        this.projectsWithDeferredDependencyUpdates.delete(projectName);
         const versionActions = this.getVersionActionsForProject(projectName);
         const cachedFinalConfigForProject = this.getCachedFinalConfigForProject(projectName);
         const dependenciesToUpdate = {};
@@ -502,11 +522,65 @@ class ReleaseGroupProcessor {
             }
         }
         const projectLogger = this.getProjectLoggerForProject(projectName);
-        const logMessages = await versionActions.updateProjectDependencies(this.tree, this.projectGraph, dependenciesToUpdate);
+        const logMessages = await versionActions.updateProjectDependencies(this.tree, this.projectGraph, dependenciesToUpdate, (dependencyProjectName) => this.resolveVersionForDependency(dependencyProjectName));
         for (const logMessage of logMessages) {
             projectLogger.buffer(logMessage);
         }
     }
+    finalizeVersionDecisionsForGroup(releaseGroup) {
+        this.groupsWithFinalizedVersionDecisions.add(releaseGroup.name);
+    }
+    async finalizeAllVersionDecisions(processOrder) {
+        const unfinalizedReleaseGroups = Array.from(this.releaseGraph.groupGraph.keys()).filter((releaseGroupName) => !this.groupsWithFinalizedVersionDecisions.has(releaseGroupName));
+        if (unfinalizedReleaseGroups.length > 0) {
+            const releaseGroupNames = unfinalizedReleaseGroups
+                .map((releaseGroupName) => `"${releaseGroupName}"`)
+                .join(', ');
+            throw new Error(`Unable to finalize version decisions for release groups ${releaseGroupNames}. Please report this as a bug on https://github.com/nrwl/nx/issues.`);
+        }
+        this.allVersionDecisionsFinalized = true;
+        for (const releaseGroupName of processOrder) {
+            const releaseGroup = this.releaseGraph.groupGraph.get(releaseGroupName);
+            for (const projectName of releaseGroup.group.projects) {
+                if (this.projectsWithDeferredDependencyUpdates.has(projectName)) {
+                    await this.updateDependenciesForProject(projectName);
+                }
+            }
+            // Keep each group's buffered output together and in processing order.
+            for (const projectName of releaseGroup.group.projects) {
+                this.getProjectLoggerForProject(projectName).flush();
+            }
+        }
+        if (this.projectsWithDeferredDependencyUpdates.size > 0) {
+            const deferredProjects = Array.from(this.projectsWithDeferredDependencyUpdates, (projectName) => `"${projectName}"`).join(', ');
+            throw new Error(`Unable to update dependencies for projects ${deferredProjects} because their release groups were not processed. Please report this as a bug on https://github.com/nrwl/nx/issues.`);
+        }
+        this.flushAllProjectLoggers();
+    }
+    /**
+     * Resolve a dependency version when `dependenciesToUpdate` does not contain
+     * a concrete version for a manifest entry.
+     *
+     * @internal
+     */
+    async resolveVersionForDependency(dependencyProjectName) {
+        const versionData = this.versionData.get(dependencyProjectName);
+        if (versionData?.newVersion) {
+            return versionData.newVersion;
+        }
+        if (!this.releaseGraph.allProjectsToProcess.has(dependencyProjectName)) {
+            return this.releaseGraph.resolveCurrentVersionForDependency(this.tree, this.projectGraph, dependencyProjectName, this.options.preid);
+        }
+        const releaseGroupName = this.getReleaseGroupNameForProject(dependencyProjectName);
+        if (!releaseGroupName ||
+            !this.groupsWithFinalizedVersionDecisions.has(releaseGroupName)) {
+            throw new Error(`Cannot resolve a concrete version for dependency project "${dependencyProjectName}" because its release group has not finalized its version decisions. Ensure the release group can finalize the dependency version before Nx Release updates the dependent manifest.`);
+        }
+        if (versionData?.currentVersion) {
+            return versionData.currentVersion;
+        }
+        throw new Error(`Cannot resolve a concrete version for dependency project "${dependencyProjectName}" because its finalized release data has no current or new version.`);
+    }
     async bumpVersionForProject(projectName, bumpType, bumpTypeReason, bumpTypeReasonData) {
         const projectLogger = this.getProjectLoggerForProject(projectName);
         if (bumpType === 'none') {

package/dist/src/command-line/release/version/version-actions.d.ts

@@ -5,6 +5,19 @@ import type { Tree } from '../../../generators/tree';
 import type { ReleaseGroupWithName } from '../config/filter-release-groups';
 import type { FinalConfigForProject } from '../utils/release-graph';
 export type SemverBumpType = ReleaseType | 'none';
+/**
+ * Lazily resolves the concrete version of a dependency project that is not
+ * already represented in `dependenciesToUpdate`.
+ *
+ * Ecosystem-specific VersionActions implementations can use this when a
+ * manifest reference requires a concrete version but `dependenciesToUpdate`
+ * does not contain one. The resolved value can be the dependency's new version
+ * when it is part of the release, or its current version when it is not being
+ * versioned.
+ *
+ * @public
+ */
+export type ResolveVersionForDependency = (dependencyProjectName: string) => Promise<string>;
 /**
  * Implementation details of performing any actions after all projects have been versioned.
  * An example might be updating a workspace level lock file.
@@ -45,6 +58,14 @@ export declare abstract class VersionActions {
      * If a manifest file is not applicable to the current versioning use-case, this should be set to null.
      */
     abstract validManifestFilenames: string[] | null;
+    /**
+     * Whether manifests updated by this implementation should be excluded from
+     * the final Prettier pass performed by Nx Release.
+     *
+     * Custom implementations must opt in explicitly. This defaults to false so
+     * their existing formatting behavior does not change.
+     */
+    excludeManifestsFromFormatting: boolean;
     /**
      * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
      * versions and dependencies are determined. If no manifest files should be updated based on the user's
@@ -170,10 +191,14 @@ export declare abstract class VersionActions {
      * with new dependency versions, but for application deployments it might involve
      * updating something else instead, it depends on the type of application.
      *
+     * `resolveVersionForDependency` is intentionally lazy: implementations
+     * decide which manifest values require a concrete version, while release core
+     * remains unaware of ecosystem-specific dependency protocols.
+     *
      * It should return an array of log messages that will be displayed unmodified to the user
      * after the dependencies have been updated.
      */
-    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
 }
 export declare class NOOP_VERSION_ACTIONS extends VersionActions {
     validManifestFilenames: any;
@@ -194,6 +219,6 @@ export declare class NOOP_VERSION_ACTIONS extends VersionActions {
         newVersion: string;
         logText: string;
     }>;
-    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
     updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
 }

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

@@ -84,6 +84,14 @@ class VersionActions {
         this.releaseGroup = releaseGroup;
         this.projectGraphNode = projectGraphNode;
         this.finalConfigForProject = finalConfigForProject;
+        /**
+         * Whether manifests updated by this implementation should be excluded from
+         * the final Prettier pass performed by Nx Release.
+         *
+         * Custom implementations must opt in explicitly. This defaults to false so
+         * their existing formatting behavior does not change.
+         */
+        this.excludeManifestsFromFormatting = false;
         /**
          * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
          * versions and dependencies are determined. If no manifest files should be updated based on the user's
@@ -237,7 +245,7 @@ class NOOP_VERSION_ACTIONS extends VersionActions {
             logText: 'Skipped default versioning as no-op.',
         });
     }
-    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
+    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate, resolveVersionForDependency) {
         return Promise.resolve([]);
     }
     updateProjectVersion(tree, newVersion) {

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

@@ -173,11 +173,15 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             // Bubble up the error so that the CLI can print the error and exit, or the programmatic API can handle it
             throw err;
         }
-        /**
-         * Ensure that formatting is applied so that version bump diffs are as minimal as possible
-         * within the context of the user's workspace.
-         */
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, { silent: true });
+        // A version actions implementation can opt its manifests out of this final
+        // pass when it already preserves their formatting while updating values.
+        const manifestsToExcludeFromFormatting = new Set(Array.from(releaseGraph.projectsToVersionActions.values()).flatMap((versionActions) => versionActions.excludeManifestsFromFormatting
+            ? versionActions.manifestsToUpdate.map(({ manifestPath }) => manifestPath)
+            : []));
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+            silent: true,
+            excludePaths: manifestsToExcludeFromFormatting,
+        });
         printAndFlushChanges(tree, !!args.dryRun);
         const { changedFiles: changed, deletedFiles: deleted } = await processor.afterAllProjectsVersioned({
             ...nxReleaseConfig.version

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

@@ -137,7 +137,12 @@ function cleanupCacheEntries() {
 }
 function cleanupNativeFileCache() {
     return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
-        (0, node_fs_1.rmSync)((0, native_file_cache_location_1.getNativeFileCacheLocation)(), { recursive: true, force: true });
+        // Null when the native cache root is not a real directory we own, which
+        // would mean deleting through a path another user planted.
+        const cacheDir = (0, native_file_cache_location_1.getNativeFileCacheLocationToDelete)();
+        if (cacheDir) {
+            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        }
     });
 }
 function cleanupWorkspaceData() {

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

@@ -51,6 +51,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, 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

@@ -41,6 +41,7 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
         process.exit(status);
     }
 }

package/dist/src/command-line/show/show-target/info.js

@@ -116,8 +116,17 @@ function resolveDependencyProjects(dep, projectName, graph) {
 function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs) {
     try {
         const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, extraTargetDeps, [projectName], [targetName], configuration, {});
-        const rootId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
-        const directDeps = taskGraph.dependencies[rootId] ?? [];
+        // `createTaskGraph` resolves the target's `defaultConfiguration`, so the real
+        // root task id may carry a `:config` suffix that `createTaskId` with the raw
+        // configuration would omit. Find the root task by (project, target) instead.
+        const rootTask = Object.values(taskGraph.tasks).find((task) => task.target.project === projectName && task.target.target === targetName);
+        const rootId = rootTask?.id ?? (0, utils_1.createTaskId)(projectName, targetName, configuration);
+        // Continuous dependencies (e.g. dev servers) live in a separate map but are
+        // direct dependencies just like the entries in `dependencies`.
+        const directDeps = [
+            ...(taskGraph.dependencies[rootId] ?? []),
+            ...(taskGraph.continuousDependencies[rootId] ?? []),
+        ];
         const directDepSet = new Set(directDeps);
         const depSourceIndices = directDeps.map((depTaskId) => {
             const task = taskGraph.tasks[depTaskId];