@storm-software/git-tools 2.130.40 → 2.131.7

package/bin/git.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import { postCheckoutHook } from './chunk-V6PBXXP5.js';
-import { postCommitHook } from './chunk-GU7L3IBA.js';
-import { postMergeHook } from './chunk-6V4HD3QJ.js';
-import { preCommitHook } from './chunk-3RY4CGUX.js';
-import './chunk-DNLVUV64.js';
-import { prePushHook } from './chunk-Y6YU46VF.js';
+import { postCheckoutHook } from './chunk-IAZL2KCV.js';
+import { postCommitHook } from './chunk-CVTLZKKX.js';
+import { postMergeHook } from './chunk-CDUCLZJV.js';
+import { preCommitHook } from './chunk-32WE3MHJ.js';
+import './chunk-NOZEXVLA.js';
+import { prePushHook } from './chunk-ABI4JM6L.js';
 import './chunk-HBLWPOJV.js';
-import { prepareHook } from './chunk-IEGXPTOH.js';
-import { run } from './chunk-G3YPGVPS.js';
-import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, brandIcon, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, isVerbose, writeWarning, defu, writeTrace, STORM_DEFAULT_RELEASE_BANNER } from './chunk-BHWWH5OI.js';
+import { prepareHook } from './chunk-AZGQVIYO.js';
+import { run, runAsync } from './chunk-RPK5AKGK.js';
+import { defu, getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, brandIcon, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, isVerbose, writeWarning, writeTrace, __require, STORM_DEFAULT_RELEASE_BANNER } from './chunk-7ES3CGZQ.js';
 import TOML from '@ltd/j-toml';
 import { Command } from 'commander';
 import '@inquirer/checkbox';
@@ -42,24 +42,36 @@ import anchor from 'anchor-markdown-header';
 import { Parser } from 'htmlparser2';
 import _ from 'underscore';
 import updateSection from 'update-section';
-import { readCachedProjectGraph as readCachedProjectGraph$1, createProjectGraphAsync as createProjectGraphAsync$2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$2, output, joinPathFragments } from '@nx/devkit';
+import { createProjectGraphAsync as createProjectGraphAsync$2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$2, readCachedProjectGraph as readCachedProjectGraph$1, output, joinPathFragments } from '@nx/devkit';
 import axios from 'axios';
 import { homedir } from 'node:os';
 import { defaultCreateReleaseProvider, GithubRemoteReleaseClient } from 'nx/src/command-line/release/utils/remote-release-clients/github';
 import { parse } from 'yaml';
 import chalk from 'chalk';
-import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes';
+import { printAndFlushChanges as printAndFlushChanges$1 } from 'nx/src/command-line/release/utils/print-changes';
 import { createGitTagValues, handleDuplicateGitTags, createCommitMessageValues, isPrerelease, shouldPreferDockerVersionForReleaseGroup, ReleaseVersion, noDiffInChangelogMessage } from 'nx/src/command-line/release/utils/shared';
 import { interpolate } from 'nx/src/tasks-runner/utils';
 import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
-import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, getGitDiff, parseCommits, gitAdd } from 'nx/src/command-line/release/utils/git';
-import { prerelease, major } from 'semver';
+import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, gitAdd, getGitDiff, parseCommits } from 'nx/src/command-line/release/utils/git';
+import semver, { prerelease, major } from 'semver';
+import clone from 'nanoclone';
 import { ReleaseClient } from 'nx/release';
+import { readRawVersionPlans, setResolvedVersionPlansOnGroups } from 'nx/src/command-line/release/config/version-plans';
+import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes.js';
+import { createReleaseGraph } from 'nx/src/command-line/release/utils/release-graph';
+import { validateResolvedVersionPlansAgainstFilter } from 'nx/src/command-line/release/utils/version-plan-utils';
 import { readNxJson } from 'nx/src/config/nx-json';
 import { FsTree } from 'nx/src/generators/tree';
 import { createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
+import importsPlugin from 'prettier-plugin-organize-imports';
 import DefaultChangelogRenderer from 'nx/release/changelog-renderer';
 import { DEFAULT_CONVENTIONAL_COMMITS_CONFIG } from 'nx/src/command-line/release/config/conventional-commits';
+import { findMatchingProjects } from 'nx/src/utils/find-matching-projects';
+import { IMPLICIT_DEFAULT_RELEASE_GROUP } from 'nx/src/command-line/release/config/config.js';
+import { deriveSpecifierFromConventionalCommits } from 'nx/src/command-line/release/version/derive-specifier-from-conventional-commits';
+import { deriveSpecifierFromVersionPlan } from 'nx/src/command-line/release/version/deriver-specifier-from-version-plans';
+import { ReleaseGroupProcessor } from 'nx/src/command-line/release/version/release-group-processor';
+import { NOOP_VERSION_ACTIONS } from 'nx/src/command-line/release/version/version-actions.js';
 
 function parseCargoToml(cargoString) {
   if (!cargoString) {
@@ -1278,11 +1290,11 @@ var formatCommitMessage = (state, workspaceConfig) => {
   const scope = workspaceConfig.variant !== "minimal" && typeof answers.scope === "string" && answers.scope ? answers.scope.trim() : "";
   const subject = answers.subject?.trim();
   const type = answers.type;
-  const format3 = config5.settings.format || (workspaceConfig.variant !== "minimal" ? "{type}({scope}): {emoji}{subject}" : "{type}: {emoji}{subject}");
+  const format4 = config5.settings.format || (workspaceConfig.variant !== "minimal" ? "{type}({scope}): {emoji}{subject}" : "{type}: {emoji}{subject}");
   const body = answers.body && typeof answers.body === "string" ? wrap(answers.body || "", wrapOptions) : "";
   const breaking = answers.breakingBody && typeof answers.breakingBody === "string" ? wrap(answers.breakingBody || "", wrapOptions) : "";
   const issues = answers.issuesBody && typeof answers.issuesBody === "string" ? wrap(answers.issuesBody || "", wrapOptions) : "";
-  const head = format3.replace(/\{emoji\}/g, config5.settings.disableEmoji ? "" : `${emoji} `).replace(/\{scope\}/g, scope).replace(/\{subject\}/g, subject || "").replace(/\{type\}/g, type || "");
+  const head = format4.replace(/\{emoji\}/g, config5.settings.disableEmoji ? "" : `${emoji} `).replace(/\{scope\}/g, scope).replace(/\{subject\}/g, subject || "").replace(/\{type\}/g, type || "");
   let msg = head;
   if (body) {
     msg += `
@@ -1988,7 +2000,7 @@ var runReadme = async ({
   project,
   output: output3,
   clean = true,
-  prettier = true,
+  prettier: prettier2 = true,
   workspace = false
 }) => {
   const projectGraph = await createProjectGraphAsync({
@@ -2023,7 +2035,7 @@ var runReadme = async ({
       templates,
       output: output3,
       clean,
-      prettier
+      prettier: prettier2
     });
   } else {
     for (const projectName of Object.keys(projectConfigs.projects)) {
@@ -2031,12 +2043,12 @@ var runReadme = async ({
         templates,
         output: output3,
         clean,
-        prettier
+        prettier: prettier2
       });
     }
   }
 };
-var runProjectReadme = async (projectName, { templates, output: output3, clean = true, prettier = true }) => {
+var runProjectReadme = async (projectName, { templates, output: output3, clean = true, prettier: prettier2 = true }) => {
   const projectGraph = await createProjectGraphAsync({
     exitOnError: true
   });
@@ -2124,10 +2136,10 @@ var runProjectReadme = async (projectName, { templates, output: output3, clean =
         }
       }
     }
-    if (prettier) {
-      const prettier2 = await import('prettier');
+    if (prettier2) {
+      const prettier3 = await import('prettier');
       console.info("Formatting output with Prettier");
-      newContent = await prettier2.format(newContent, {
+      newContent = await prettier3.format(newContent, {
         parser: "markdown",
         trailingComma: "none",
         tabWidth: 2,
@@ -2614,7 +2626,7 @@ async function generateChangelogForProjects({
         workspaceConfig
       );
       tree.write(filePath, content);
-      printAndFlushChanges(
+      printAndFlushChanges$1(
         tree,
         !!args.dryRun,
         3,
@@ -3003,6 +3015,54 @@ async function isUserAnOrganizationMember(userId, config5, remoteName = "origin"
     return false;
   }
 }
+
+// src/utilities/logs.ts
+function formatNxLog(message) {
+  const { title, bodyLines } = message;
+  return `${title}${bodyLines && bodyLines.length > 0 ? `
+${bodyLines.map((line) => `  ${line}`).join("\n")}` : ""}`;
+}
+async function format3(path, data) {
+  let code = data;
+  try {
+    const resolvedConfig = await resolveConfig(path);
+    if (resolvedConfig) {
+      code = await format(
+        data,
+        defu(
+          {
+            absolutePath: path,
+            ...resolvedConfig
+          },
+          path.endsWith(".ts") || path.endsWith(".tsx") ? { plugins: [importsPlugin] } : {}
+        )
+      );
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to format file at ${path} with Prettier: ${error.message}`,
+      { cause: error }
+    );
+  }
+  return code;
+}
+async function formatChangedFiles(tree) {
+  if (process.env.NX_SKIP_FORMAT === "true") {
+    return;
+  }
+  const files = new Set(
+    tree.listChanges().filter((file) => file.type !== "DELETE")
+  );
+  const results = await Promise.all(
+    Array.from(files).filter((file) => file.content && file.path).map(async (file) => [
+      file.path,
+      await format3(file.path, file.content?.toString("utf-8") ?? "")
+    ])
+  );
+  for (const [path, content] of results) {
+    tree.write(path, content);
+  }
+}
 var StormChangelogRenderer = class extends DefaultChangelogRenderer {
   /**
    * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
@@ -3206,38 +3266,112 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
   }
 };
 
-// src/release/config.ts
+// ../package-constants/src/tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  }};
+var formatProjectTag = (variant, value) => {
+  return `${variant}:${value}`;
+};
+var hasProjectTag = (project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some(
+    (tag) => tag.startsWith(prefix) && tag.length > prefix.length
+  );
+};
+var getProjectTag = (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return tag?.replace(prefix, "");
+};
+var isEqualProjectTag = (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+};
 var DEFAULT_CONVENTIONAL_COMMITS_CONFIG2 = {
   useCommitScope: true,
   questions: DEFAULT_MONOREPO_COMMIT_QUESTIONS,
   types: DEFAULT_COMMIT_TYPES
 };
-var DEFAULT_RELEASE_TAG_PATTERN = "{projectName}@{version}";
+var DEFAULT_INDEPENDENT_RELEASE_TAG_PATTERN = "{projectName}@{version}";
+var DEFAULT_FIXED_RELEASE_TAG_PATTERN = "{releaseGroupName}@{version}";
+var DEFAULT_COMMIT_MESSAGE = "release(monorepo): Publish v{version} release updates";
+var DEFAULT_RELEASE_GROUP_GIT_CONFIG = {
+  commit: false,
+  commitMessage: DEFAULT_COMMIT_MESSAGE,
+  commitArgs: "",
+  tag: false,
+  tagMessage: "",
+  tagArgs: "",
+  stageChanges: false,
+  pushArgs: ""
+};
+var DEFAULT_VERSION_RELEASE_CONFIG = {
+  currentVersionResolver: "git-tag",
+  fallbackCurrentVersionResolver: "disk",
+  specifierSource: "conventional-commits",
+  groupPreVersionCommand: "pnpm build",
+  preserveLocalDependencyProtocols: true,
+  preserveMatchingDependencyRanges: true,
+  logUnchangedProjects: true,
+  updateDependents: "always",
+  git: {
+    ...DEFAULT_RELEASE_GROUP_GIT_CONFIG,
+    stageChanges: true
+  }
+};
+var DEFAULT_CHANGELOG_RELEASE_CONFIG = {
+  createRelease: "github",
+  entryWhenNoChanges: "This was a version bump only for {projectName} to align it with other projects, there were no code changes.",
+  file: false,
+  renderOptions: {
+    authors: false,
+    commitReferences: true,
+    versionTitleDate: true
+  },
+  git: {
+    ...DEFAULT_RELEASE_GROUP_GIT_CONFIG,
+    commit: true,
+    tag: true,
+    push: true
+  }
+};
 var DEFAULT_RELEASE_GROUP_CONFIG = {
   projectsRelationship: "independent",
   changelog: {
-    createRelease: "github",
-    entryWhenNoChanges: false,
-    file: false,
-    renderOptions: {
-      authors: false,
-      commitReferences: true,
-      versionTitleDate: true
-    }
+    ...DEFAULT_CHANGELOG_RELEASE_CONFIG
   },
   version: {
-    currentVersionResolver: "git-tag",
-    fallbackCurrentVersionResolver: "disk",
-    specifierSource: "conventional-commits",
-    groupPreVersionCommand: "pnpm build"
+    ...DEFAULT_VERSION_RELEASE_CONFIG
   },
-  releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
+  releaseTag: {
+    pattern: DEFAULT_INDEPENDENT_RELEASE_TAG_PATTERN,
+    preferDockerVersion: false
+  },
+  versionPlans: false
+};
+var DEFAULT_INDEPENDENT_RELEASE_GROUP_CONFIG = {
+  projectsRelationship: "independent",
+  releaseTag: {
+    pattern: DEFAULT_INDEPENDENT_RELEASE_TAG_PATTERN
+  }
+};
+var DEFAULT_FIXED_RELEASE_GROUP_CONFIG = {
+  projectsRelationship: "fixed",
+  releaseTag: {
+    pattern: DEFAULT_FIXED_RELEASE_TAG_PATTERN
+  }
 };
 var DEFAULT_JS_RELEASE_GROUP_CONFIG = {
-  ...DEFAULT_RELEASE_GROUP_CONFIG,
-  projects: ["packages/*"],
   version: {
-    ...DEFAULT_RELEASE_GROUP_CONFIG.version,
     versionActions: "@storm-software/workspace-tools/release/js-version-actions",
     versionActionsOptions: {
       currentVersionResolver: "git-tag",
@@ -3253,10 +3387,7 @@ var DEFAULT_JS_RELEASE_GROUP_CONFIG = {
   }
 };
 var DEFAULT_RUST_RELEASE_GROUP_CONFIG = {
-  ...DEFAULT_RELEASE_GROUP_CONFIG,
-  projects: ["crates/*"],
   version: {
-    ...DEFAULT_RELEASE_GROUP_CONFIG.version,
     versionActions: "@storm-software/workspace-tools/release/rust-version-actions",
     versionActionsOptions: {
       currentVersionResolver: "git-tag",
@@ -3268,40 +3399,123 @@ var DEFAULT_RUST_RELEASE_GROUP_CONFIG = {
 var DEFAULT_RELEASE_CONFIG = {
   conventionalCommits: DEFAULT_CONVENTIONAL_COMMITS_CONFIG2,
   groups: {
-    packages: DEFAULT_JS_RELEASE_GROUP_CONFIG,
-    crates: DEFAULT_RUST_RELEASE_GROUP_CONFIG
+    packages: defu(
+      {
+        projects: ["packages/*"]
+      },
+      DEFAULT_JS_RELEASE_GROUP_CONFIG,
+      DEFAULT_RELEASE_GROUP_CONFIG
+    ),
+    crates: defu(
+      {
+        projects: ["crates/*"]
+      },
+      DEFAULT_RUST_RELEASE_GROUP_CONFIG,
+      DEFAULT_RELEASE_GROUP_CONFIG
+    )
   },
   changelog: {
+    ...DEFAULT_CHANGELOG_RELEASE_CONFIG,
     automaticFromRef: true,
     workspaceChangelog: false,
     projectChangelogs: true
   },
-  releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
+  releaseTag: {
+    pattern: DEFAULT_INDEPENDENT_RELEASE_TAG_PATTERN,
+    preferDockerVersion: false
+  },
+  version: {
+    ...DEFAULT_VERSION_RELEASE_CONFIG
+  }
 };
-function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
+function mergeReleaseGroupConfig(config5, defaultConfig, workspaceConfig) {
+  return defu(
+    {
+      ...omit(defaultConfig, ["changelog", "version"]),
+      ...config5
+    },
+    {
+      version: {
+        ...defaultConfig.version
+      }
+    },
+    {
+      changelog: {
+        ...typeof defaultConfig.changelog === "object" ? defaultConfig.changelog : {},
+        renderer: StormChangelogRenderer,
+        renderOptions: {
+          ...typeof defaultConfig.changelog === "object" && defaultConfig.changelog.renderOptions || {},
+          workspaceConfig
+        }
+      }
+    }
+  );
+}
+function getReleaseGroupConfig(projectGraph, releaseConfig, workspaceConfig) {
+  const alreadyMatchedProjects = /* @__PURE__ */ new Set();
   return !releaseConfig?.groups || Object.keys(releaseConfig.groups).length === 0 ? {} : Object.fromEntries(
     Object.entries(releaseConfig.groups).map(([name, group]) => {
-      const config5 = defu(
-        {
-          ...omit(DEFAULT_RELEASE_GROUP_CONFIG, ["changelog", "version"]),
-          ...group
-        },
-        {
-          version: {
-            ...DEFAULT_RELEASE_GROUP_CONFIG.version
-          }
-        },
-        {
-          changelog: {
-            ...DEFAULT_RELEASE_GROUP_CONFIG.changelog,
-            renderer: StormChangelogRenderer,
-            renderOptions: {
-              ...DEFAULT_RELEASE_GROUP_CONFIG.changelog.renderOptions,
-              workspaceConfig
-            }
-          }
+      const matchingProjects = findMatchingProjects(
+        typeof group.projects === "string" ? [group.projects] : group.projects,
+        projectGraph.nodes
+      );
+      if (!matchingProjects.length) {
+        throw new Error(
+          `Release group "${name}" does not have any matching projects.`
+        );
+      }
+      for (const project of matchingProjects) {
+        if (alreadyMatchedProjects.has(project)) {
+          throw new Error(
+            `Project "${project}" is included in more than one release group. Please ensure that each project is only included in one release group, or remove the "projects" property from the release group configuration to allow it to be included in the same release group as other projects with overlapping globs.`
+          );
         }
+        alreadyMatchedProjects.add(project);
+      }
+      let languageDefaultConfig = {};
+      if (matchingProjects.every(
+        (project) => projectGraph.nodes[project]?.data && (projectGraph.nodes[project]?.data.metadata?.js || isEqualProjectTag(
+          projectGraph.nodes[project]?.data,
+          ProjectTagConstants.Language.TAG_ID,
+          ProjectTagConstants.Language.TYPESCRIPT
+        ) || projectGraph.nodes[project]?.data.metadata?.root && existsSync$1(
+          joinPaths(
+            projectGraph.nodes[project]?.data.metadata?.root,
+            "package.json"
+          )
+        ))
+      )) {
+        languageDefaultConfig = defu(
+          DEFAULT_JS_RELEASE_GROUP_CONFIG,
+          DEFAULT_RELEASE_GROUP_CONFIG
+        );
+      } else if (matchingProjects.every(
+        (project) => projectGraph.nodes[project]?.data && (projectGraph.nodes[project]?.data.metadata?.rust || projectGraph.nodes[project]?.data.metadata?.cargo || isEqualProjectTag(
+          projectGraph.nodes[project]?.data,
+          ProjectTagConstants.Language.TAG_ID,
+          ProjectTagConstants.Language.RUST
+        ) || projectGraph.nodes[project]?.data.metadata?.root && existsSync$1(
+          joinPaths(
+            projectGraph.nodes[project]?.data.metadata?.root,
+            "Cargo.toml"
+          )
+        ))
+      )) {
+        languageDefaultConfig = defu(
+          DEFAULT_RUST_RELEASE_GROUP_CONFIG,
+          DEFAULT_RELEASE_GROUP_CONFIG
+        );
+      }
+      const config5 = mergeReleaseGroupConfig(
+        group,
+        defu(
+          languageDefaultConfig,
+          group.projectsRelationship === "fixed" ? DEFAULT_FIXED_RELEASE_GROUP_CONFIG : DEFAULT_INDEPENDENT_RELEASE_GROUP_CONFIG,
+          DEFAULT_RELEASE_GROUP_CONFIG
+        ),
+        workspaceConfig
       );
+      config5.projects = matchingProjects;
       if (workspaceConfig?.workspaceRoot) {
         if (config5.changelog?.renderer && typeof config5.changelog?.renderer === "string" && config5.changelog?.renderer?.toString().startsWith("./")) {
           config5.changelog.renderer = joinPaths(
@@ -3320,6 +3534,658 @@ function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
     })
   );
 }
+var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
+  constructor(tree, workspaceConfig, projectGraph, nxReleaseConfig, releaseGraph, versionOptions) {
+    super(tree, projectGraph, nxReleaseConfig, releaseGraph, {
+      dryRun: !!versionOptions.dryRun,
+      verbose: versionOptions.verbose || isVerbose(workspaceConfig.logLevel),
+      firstRelease: !!versionOptions.firstRelease,
+      preid: versionOptions.preid ?? workspaceConfig.preid ?? "",
+      userGivenSpecifier: versionOptions.specifier,
+      filters: {
+        projects: versionOptions.projects,
+        groups: versionOptions.groups
+      },
+      versionActionsOptionsOverrides: versionOptions.versionActionsOptionsOverrides
+    });
+    this.workspaceConfig = workspaceConfig;
+    this.versionOptions = versionOptions;
+    this.#tree = tree;
+    this.#projectGraph = projectGraph;
+    this.#nxReleaseConfig = nxReleaseConfig;
+    this.#releaseGraph = releaseGraph;
+  }
+  #tree;
+  #projectGraph;
+  #nxReleaseConfig;
+  #releaseGraph;
+  /**
+   * Track any version plan files that have been processed so that we can delete them after versioning is complete,
+   * while leaving any unprocessed files in place.
+   */
+  #processedVersionPlanFiles = /* @__PURE__ */ new Set();
+  /**
+   * Tracks which release groups have already been processed to avoid
+   * processing them multiple times. Used during the group traversal.
+   */
+  #processedGroups = /* @__PURE__ */ new Set();
+  /**
+   * Keeps track of which projects have already had their versions bumped.
+   * This is used to avoid redundant version bumping and to determine which
+   * projects need their dependencies updated.
+   */
+  #bumpedProjects = /* @__PURE__ */ new Set();
+  /**
+   * versionData that will ultimately be returned to the nx release version handler by getVersionData()
+   */
+  #versionData = /* @__PURE__ */ new Map();
+  getReleaseGroupNameForProject(projectName) {
+    const group = this.#releaseGraph.projectToReleaseGroup.get(projectName);
+    return group ? group.name : null;
+  }
+  getNextGroup() {
+    for (const [groupName, groupNode] of this.#releaseGraph.groupGraph) {
+      if (!this.#processedGroups.has(groupName) && Array.from(groupNode.dependencies).every(
+        (dep) => this.#processedGroups.has(dep)
+      )) {
+        return groupName;
+      }
+    }
+    return null;
+  }
+  flushAllProjectLoggers() {
+    for (const projectLogger of this.#releaseGraph.projectLoggers.values()) {
+      projectLogger.flush();
+    }
+  }
+  deleteProcessedVersionPlanFiles() {
+    for (const versionPlanPath of this.#processedVersionPlanFiles) {
+      this.#tree.delete(versionPlanPath);
+    }
+  }
+  getVersionData() {
+    return Object.fromEntries(this.#versionData);
+  }
+  /**
+   * Invoke the afterAllProjectsVersioned functions for each unique versionActions type.
+   * This can be useful for performing actions like updating a workspace level lock file.
+   *
+   * Because the tree has already been flushed to disk at this point, each afterAllProjectsVersioned
+   * function is responsible for returning the list of changed and deleted files that it affected.
+   *
+   * The root level `release.version.versionActionsOptions` is what is passed in here because this
+   * is a one time action for the whole workspace. Release group and project level overrides are
+   * not applicable.
+   */
+  async afterAllProjectsVersioned(rootVersionActionsOptions) {
+    const changedFiles = /* @__PURE__ */ new Set();
+    const deletedFiles = /* @__PURE__ */ new Set();
+    for (const [, afterAllProjectsVersioned] of this.#releaseGraph.uniqueAfterAllProjectsVersioned) {
+      const {
+        changedFiles: changedFilesForVersionActions,
+        deletedFiles: deletedFilesForVersionActions
+      } = await afterAllProjectsVersioned(this.#tree.root, {
+        dryRun: this.versionOptions.dryRun,
+        verbose: this.versionOptions.verbose || isVerbose(this.workspaceConfig.logLevel),
+        rootVersionActionsOptions
+      });
+      for (const file of changedFilesForVersionActions) {
+        changedFiles.add(file);
+      }
+      for (const file of deletedFilesForVersionActions) {
+        deletedFiles.add(file);
+      }
+    }
+    return {
+      changedFiles: Array.from(changedFiles),
+      deletedFiles: Array.from(deletedFiles)
+    };
+  }
+  async processDockerProjects(dockerVersionScheme, dockerVersion) {
+    const dockerProjects = /* @__PURE__ */ new Map();
+    for (const project of this.#versionData.keys()) {
+      const hasDockerTechnology = Object.values(
+        this.#projectGraph.nodes[project]?.data?.targets ?? []
+      ).some(({ metadata }) => metadata?.technologies?.includes("docker"));
+      if (!hasDockerTechnology) {
+        continue;
+      }
+      const finalConfigForProject = this.#releaseGraph.finalConfigsByProject.get(project);
+      dockerProjects.set(project, finalConfigForProject);
+    }
+    if (dockerProjects.size === 0) {
+      return;
+    }
+    let handleDockerVersion;
+    try {
+      const dockerVersionUtilsPath = "@nx/docker/release/version-utils";
+      const { handleDockerVersion: _handleDockerVersion } = __require(dockerVersionUtilsPath);
+      handleDockerVersion = _handleDockerVersion;
+    } catch (e) {
+      console.error(
+        "Could not find `@nx/docker`. Please run `nx add @nx/docker` before attempting to release Docker images."
+      );
+      throw e;
+    }
+    for (const [project, finalConfigForProject] of dockerProjects.entries()) {
+      const projectNode = this.#projectGraph.nodes[project];
+      const projectVersionData = this.#versionData.get(project);
+      const { newVersion, logs } = await handleDockerVersion(
+        this.workspaceConfig.workspaceRoot,
+        projectNode,
+        finalConfigForProject,
+        dockerVersionScheme,
+        dockerVersion,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-non-null-asserted-optional-chain
+        projectVersionData?.newVersion
+      );
+      logs.forEach(
+        (log) => this.#getProjectLoggerForProject(project).buffer(log)
+      );
+      const newVersionData = {
+        ...projectVersionData,
+        dockerVersion: newVersion
+      };
+      this.#versionData.set(project, newVersionData);
+    }
+    this.flushAllProjectLoggers();
+  }
+  async processGroups() {
+    const processOrder = [];
+    for (const nextGroup of this.#releaseGraph.sortedReleaseGroups) {
+      if (this.#processedGroups.has(nextGroup)) {
+        continue;
+      }
+      if (!this.#releaseGraph.groupGraph.has(nextGroup)) {
+        continue;
+      }
+      const allDependenciesProcessed = Array.from(
+        this.#releaseGraph.groupGraph.get(nextGroup).dependencies
+      ).every((dep) => this.#processedGroups.has(dep));
+      if (!allDependenciesProcessed) {
+        for (const dep of this.#releaseGraph.groupGraph.get(nextGroup).dependencies) {
+          if (!this.#processedGroups.has(dep)) {
+            if (!this.#releaseGraph.groupGraph.has(dep)) {
+              continue;
+            }
+            await this.#processGroup(dep);
+            this.#processedGroups.add(dep);
+            processOrder.push(dep);
+          }
+        }
+      }
+      await this.#processGroup(nextGroup);
+      this.#processedGroups.add(nextGroup);
+      processOrder.push(nextGroup);
+    }
+    return processOrder;
+  }
+  async #bumpVersions(releaseGroup) {
+    if (releaseGroup.projectsRelationship === "fixed") {
+      return this.#bumpFixedVersionGroup(releaseGroup);
+    } else {
+      return this.#bumpIndependentVersionGroup(releaseGroup);
+    }
+  }
+  async #processGroup(releaseGroupName) {
+    const groupNode = this.#releaseGraph.groupGraph.get(releaseGroupName);
+    await this.#bumpVersions(groupNode.group);
+    for (const project of groupNode.group.projects) {
+      const projectLogger = this.#releaseGraph.projectLoggers.get(project);
+      if (!projectLogger) {
+        throw new Error(
+          `No project logger found for project ${project} in release group ${releaseGroupName}. This should never happen.`
+        );
+      }
+      projectLogger.flush();
+    }
+  }
+  async #bumpFixedVersionGroup(releaseGroup) {
+    if (releaseGroup.projects.length === 0) {
+      return false;
+    }
+    let bumped = false;
+    const firstProject = releaseGroup.projects.reduce((acc, project) => {
+      const currentVersion = this.#getCurrentCachedVersionForProject(project);
+      if (currentVersion && semver.gt(currentVersion, acc)) {
+        return currentVersion;
+      }
+      return acc;
+    }, "");
+    const {
+      newVersionInput,
+      newVersionInputReason,
+      newVersionInputReasonData
+    } = await this.#determineVersionBumpForProject(releaseGroup, firstProject);
+    if (newVersionInput === "none") {
+      let bumpedByDependency = false;
+      const sortedProjects2 = this.#releaseGraph.sortedProjects.get(releaseGroup.name) || [];
+      for (const project of sortedProjects2) {
+        const dependencies = this.#projectGraph.dependencies[project] || [];
+        for (const dep of dependencies) {
+          const depGroup = this.getReleaseGroupNameForProject(dep.target);
+          if (depGroup && depGroup !== releaseGroup.name && this.#processedGroups.has(depGroup)) {
+            const depGroupBumpType = await this.#getFixedReleaseGroupBumpType(depGroup);
+            if (depGroupBumpType !== "none") {
+              bumpedByDependency = true;
+              const depBumpType = this.#determineSideEffectBump(
+                releaseGroup,
+                depGroupBumpType
+              );
+              await this.#bumpVersionForProject(
+                project,
+                depBumpType,
+                "DEPENDENCY_ACROSS_GROUPS_WAS_BUMPED",
+                {}
+              );
+              this.#bumpedProjects.add(project);
+              await this.#updateDependenciesForProject(project);
+            }
+          }
+        }
+      }
+      if (bumpedByDependency) {
+        for (const project of sortedProjects2) {
+          if (!this.#bumpedProjects.has(project)) {
+            await this.#bumpVersionForProject(
+              project,
+              this.#applyPreidToBumpType("patch", project),
+              "OTHER_PROJECT_IN_FIXED_GROUP_WAS_BUMPED_DUE_TO_DEPENDENCY",
+              {}
+            );
+            this.#bumpedProjects.add(project);
+            await this.#updateDependenciesForProject(project);
+          }
+        }
+      } else {
+        for (const project of releaseGroup.projects) {
+          this.#versionData.set(project, {
+            currentVersion: this.#getCurrentCachedVersionForProject(
+              project
+            ),
+            newVersion: null,
+            dockerVersion: null,
+            dependentProjects: this.#getOriginalDependentProjects(project)
+          });
+          if (project === firstProject) {
+            continue;
+          }
+          const projectLogger = this.#getProjectLoggerForProject(project);
+          projectLogger.buffer(
+            `\u{1F6AB} Skipping versioning for ${project} as it is a part of a fixed release group with ${firstProject} and no dependency bumps were detected`
+          );
+        }
+      }
+      return bumpedByDependency;
+    }
+    const { newVersion } = await this.#calculateNewVersion(
+      firstProject,
+      newVersionInput,
+      newVersionInputReason,
+      newVersionInputReasonData
+    );
+    const sortedProjects = this.#releaseGraph.sortedProjects.get(releaseGroup.name) || releaseGroup.projects;
+    for (const project of sortedProjects) {
+      const versionActions = this.#getVersionActionsForProject(project);
+      const projectLogger = this.#getProjectLoggerForProject(project);
+      const currentVersion = this.#getCurrentCachedVersionForProject(
+        project
+      );
+      if (project !== firstProject) {
+        projectLogger.buffer(
+          `\u2753 Applied version ${newVersion} directly, because the project is a member of a fixed release group containing ${firstProject}`
+        );
+      }
+      const logMessages = await versionActions.updateProjectVersion(
+        this.#tree,
+        newVersion
+      );
+      for (const logMessage of logMessages) {
+        projectLogger.buffer(logMessage);
+      }
+      this.#bumpedProjects.add(project);
+      bumped = true;
+      this.#versionData.set(project, {
+        currentVersion,
+        newVersion,
+        dependentProjects: this.#getOriginalDependentProjects(project)
+      });
+    }
+    if (bumped) {
+      for (const project of sortedProjects) {
+        await this.#updateDependenciesForProject(project);
+      }
+    }
+    return bumped;
+  }
+  #getOriginalDependentProjects(project) {
+    return this.#releaseGraph.originalDependentProjectsPerProject.get(project) || [];
+  }
+  async #updateDependenciesForProject(projectName) {
+    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`
+      );
+    }
+    const versionActions = this.#getVersionActionsForProject(projectName);
+    const cachedFinalConfigForProject = this.#getCachedFinalConfigForProject(projectName);
+    const dependenciesToUpdate = {};
+    const dependencies = this.#projectGraph.dependencies[projectName] || [];
+    for (const dep of dependencies) {
+      if (this.#releaseGraph.allProjectsToProcess.has(dep.target)) {
+        const targetVersionData = this.#versionData.get(dep.target);
+        if (targetVersionData) {
+          const { currentVersion: currentDependencyVersion } = await versionActions.readCurrentVersionOfDependency(
+            this.#tree,
+            this.#projectGraph,
+            dep.target
+          );
+          if (!currentDependencyVersion) {
+            continue;
+          }
+          let finalPrefix = "";
+          if (cachedFinalConfigForProject.versionPrefix === "auto") {
+            const prefixMatch = currentDependencyVersion?.match(/^([~^=])/);
+            finalPrefix = prefixMatch ? prefixMatch[1] : "";
+          } else if (cachedFinalConfigForProject.versionPrefix && ["~", "^", "="].includes(cachedFinalConfigForProject.versionPrefix)) {
+            finalPrefix = cachedFinalConfigForProject.versionPrefix;
+          }
+          const newVersion = targetVersionData.newVersion ?? this.#releaseGraph.cachedCurrentVersions.get(dep.target) ?? currentDependencyVersion;
+          const cleanNewVersion = newVersion.replace(/^[~^=]/, "");
+          dependenciesToUpdate[dep.target] = `${finalPrefix}${cleanNewVersion}`;
+        }
+      }
+    }
+    const projectLogger = this.#getProjectLoggerForProject(projectName);
+    const logMessages = await versionActions.updateProjectDependencies(
+      this.#tree,
+      this.#projectGraph,
+      dependenciesToUpdate
+    );
+    for (const logMessage of logMessages) {
+      projectLogger.buffer(logMessage);
+    }
+  }
+  #getVersionActionsForProject(projectName) {
+    const versionActions = this.#releaseGraph.projectsToVersionActions.get(projectName);
+    if (!versionActions) {
+      throw new Error(
+        `No versionActions found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`
+      );
+    }
+    return versionActions;
+  }
+  async #getFixedReleaseGroupBumpType(releaseGroupName) {
+    const releaseGroup = this.#releaseGraph.groupGraph.get(releaseGroupName).group;
+    const releaseGroupFilteredProjects = this.#releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup);
+    if (!releaseGroupFilteredProjects || releaseGroupFilteredProjects.size === 0) {
+      return "none";
+    }
+    const anyProject = releaseGroupFilteredProjects.values().next().value;
+    const { currentVersion, newVersion } = this.#versionData.get(anyProject);
+    if (newVersion) {
+      return semver.diff(currentVersion, newVersion);
+    }
+    return (await this.#determineVersionBumpForProject(releaseGroup, anyProject)).newVersionInput;
+  }
+  // TODO: Support influencing the side effect bump in a future version, always patch for now like in legacy versioning
+  #determineSideEffectBump(releaseGroup, dependencyBumpType) {
+    const anyProject = releaseGroup.projects[0];
+    return this.#applyPreidToBumpType("patch", anyProject);
+  }
+  /**
+   * When a preid is set (e.g. --preid rc) and the project has opted in via
+   * `applyPreidToDependents`, convert a "patch" side-effect bump into a
+   * "prepatch" so that semver.inc() actually applies the preid.
+   * semver.inc('1.0.0', 'patch', 'rc') ignores preid and returns '1.0.1'.
+   * semver.inc('1.0.0', 'prepatch', 'rc') returns '1.0.1-rc.0' as expected.
+   */
+  #applyPreidToBumpType(bumpType, projectName) {
+    if (!(this.versionOptions.preid && this.workspaceConfig.preid) || bumpType === "none" || bumpType.startsWith("pre")) {
+      return bumpType;
+    }
+    const finalConfig = this.#getCachedFinalConfigForProject(projectName);
+    if (!finalConfig.applyPreidToDependents) {
+      return bumpType;
+    }
+    switch (bumpType) {
+      case "major":
+        return "premajor";
+      case "minor":
+        return "preminor";
+      case "patch":
+        return "prepatch";
+      default:
+        return bumpType;
+    }
+  }
+  #getCachedFinalConfigForProject(projectName) {
+    const cachedFinalConfig = this.#releaseGraph.finalConfigsByProject.get(projectName);
+    if (!cachedFinalConfig) {
+      throw new Error(
+        `Unexpected error: No cached config found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`
+      );
+    }
+    return cachedFinalConfig;
+  }
+  async #bumpIndependentVersionGroup(releaseGroup) {
+    const releaseGroupFilteredProjects = this.#releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup);
+    let bumped = false;
+    const projectBumpTypes = /* @__PURE__ */ new Map();
+    const projectsToUpdate = /* @__PURE__ */ new Set();
+    if (releaseGroupFilteredProjects && releaseGroupFilteredProjects.size > 0) {
+      for (const project of releaseGroupFilteredProjects) {
+        const {
+          newVersionInput: bumpType,
+          newVersionInputReason: bumpTypeReason,
+          newVersionInputReasonData: bumpTypeReasonData
+        } = await this.#determineVersionBumpForProject(releaseGroup, project);
+        projectBumpTypes.set(project, {
+          bumpType,
+          bumpTypeReason,
+          bumpTypeReasonData
+        });
+        if (bumpType !== "none") {
+          projectsToUpdate.add(project);
+        }
+      }
+      const sortedProjects = this.#releaseGraph.sortedProjects.get(releaseGroup.name) || [];
+      for (const project of sortedProjects) {
+        if (projectsToUpdate.has(project) && releaseGroupFilteredProjects?.has(project)) {
+          const {
+            bumpType: finalBumpType,
+            bumpTypeReason: finalBumpTypeReason,
+            bumpTypeReasonData: finalBumpTypeReasonData
+          } = projectBumpTypes.get(project);
+          if (finalBumpType !== "none") {
+            await this.#bumpVersionForProject(
+              project,
+              finalBumpType,
+              finalBumpTypeReason,
+              finalBumpTypeReasonData
+            );
+            this.#bumpedProjects.add(project);
+            bumped = true;
+          }
+        }
+      }
+      for (const project of sortedProjects) {
+        if (projectsToUpdate.has(project) && releaseGroupFilteredProjects?.has(project)) {
+          await this.#updateDependenciesForProject(project);
+        }
+      }
+    }
+    return bumped;
+  }
+  #getCurrentCachedVersionForProject(projectName) {
+    return this.#releaseGraph.cachedCurrentVersions.get(projectName) || null;
+  }
+  async #calculateNewVersion(project, newVersionInput, newVersionInputReason, newVersionInputReasonData) {
+    const currentVersion = this.#getCurrentCachedVersionForProject(project);
+    const versionActions = this.#getVersionActionsForProject(project);
+    const { newVersion, logText } = await versionActions.calculateNewVersion(
+      currentVersion,
+      newVersionInput,
+      newVersionInputReason,
+      newVersionInputReasonData,
+      this.versionOptions.preid || this.workspaceConfig.preid || ""
+    );
+    const projectLogger = this.#getProjectLoggerForProject(project);
+    projectLogger.buffer(logText);
+    return { currentVersion, newVersion };
+  }
+  async #bumpVersionForProject(projectName, bumpType, bumpTypeReason, bumpTypeReasonData) {
+    const projectLogger = this.#getProjectLoggerForProject(projectName);
+    if (bumpType === "none") {
+      projectLogger.buffer(
+        `\u23E9 Skipping bump for ${projectName} as bump type is "none"`
+      );
+      return;
+    }
+    const versionActions = this.#getVersionActionsForProject(projectName);
+    const { currentVersion, newVersion } = await this.#calculateNewVersion(
+      projectName,
+      bumpType,
+      bumpTypeReason,
+      bumpTypeReasonData
+    );
+    const logMessages = await versionActions.updateProjectVersion(
+      this.#tree,
+      newVersion
+    );
+    for (const logMessage of logMessages) {
+      projectLogger.buffer(logMessage);
+    }
+    this.#versionData.set(projectName, {
+      currentVersion,
+      newVersion,
+      dependentProjects: this.#getOriginalDependentProjects(projectName)
+    });
+    this.#bumpedProjects.add(projectName);
+    const releaseGroupName = this.getReleaseGroupNameForProject(projectName);
+    if (!releaseGroupName) {
+      projectLogger.buffer(
+        `\u26A0\uFE0F Cannot find release group for ${projectName}, skipping dependent updates`
+      );
+      return;
+    }
+    const releaseGroup = this.#releaseGraph.groupGraph.get(releaseGroupName).group;
+    const releaseGroupVersionConfig = releaseGroup.version;
+    const updateDependents = releaseGroupVersionConfig?.updateDependents || "always";
+    if (updateDependents === "auto" || updateDependents === "always") {
+      const dependents = this.#getNonImplicitDependentsForProject(projectName);
+      const dependentsToProcess = dependents.filter(
+        (dep) => this.#releaseGraph.allProjectsToProcess.has(dep)
+      );
+      await this.#updateDependenciesForDependents(dependentsToProcess);
+      for (const dependent of dependentsToProcess) {
+        if (!this.#bumpedProjects.has(dependent)) {
+          await this.#bumpVersionForProject(
+            dependent,
+            this.#applyPreidToBumpType("patch", dependent),
+            "DEPENDENCY_WAS_BUMPED",
+            {}
+          );
+        }
+      }
+    } else {
+      const releaseGroupText = releaseGroupName !== IMPLICIT_DEFAULT_RELEASE_GROUP ? ` in release group "${releaseGroupName}" ` : " ";
+      projectLogger.buffer(
+        `\u23E9 Skipping dependent updates as "updateDependents"${releaseGroupText}is not "auto"`
+      );
+    }
+  }
+  #getProjectDependents(project) {
+    return this.#releaseGraph.projectToDependents.get(project) || /* @__PURE__ */ new Set();
+  }
+  #getNonImplicitDependentsForProject(project) {
+    return Array.from(this.#getProjectDependents(project));
+  }
+  async #updateDependenciesForDependents(dependents) {
+    for (const dependent of dependents) {
+      if (!this.#releaseGraph?.allProjectsToProcess.has(dependent)) {
+        throw new Error(
+          `Unable to find project "${dependent}" in allProjectsToProcess, please report this as a bug on https://github.com/nrwl/nx/issues`
+        );
+      }
+      await this.#updateDependenciesForProject(dependent);
+    }
+  }
+  async #determineVersionBumpForProject(releaseGroup, projectName) {
+    if (this.versionOptions.specifier) {
+      return {
+        newVersionInput: this.versionOptions.specifier,
+        newVersionInputReason: "USER_SPECIFIER",
+        newVersionInputReasonData: {}
+      };
+    }
+    const projectGraphNode = this.#projectGraph.nodes[projectName];
+    const projectLogger = this.#getProjectLoggerForProject(projectName);
+    const cachedFinalConfigForProject = this.#getCachedFinalConfigForProject(projectName);
+    if (cachedFinalConfigForProject.specifierSource === "conventional-commits") {
+      const currentVersion = this.#getCurrentCachedVersionForProject(projectName);
+      const bumpType = await deriveSpecifierFromConventionalCommits(
+        {
+          ...this.#nxReleaseConfig,
+          git: this.#nxReleaseConfig.git ?? {}
+        },
+        this.#projectGraph,
+        projectLogger,
+        releaseGroup,
+        projectGraphNode,
+        !!semver.prerelease(currentVersion ?? ""),
+        this.#releaseGraph.cachedLatestMatchingGitTag.get(projectName),
+        this.#releaseGraph,
+        cachedFinalConfigForProject.fallbackCurrentVersionResolver,
+        this.versionOptions.preid || this.workspaceConfig.preid || ""
+      );
+      return {
+        newVersionInput: bumpType,
+        newVersionInputReason: "CONVENTIONAL_COMMITS",
+        newVersionInputReasonData: {}
+      };
+    }
+    if (releaseGroup.versionPlans) {
+      const currentVersion = this.#getCurrentCachedVersionForProject(projectName);
+      const { bumpType, versionPlanPath } = await deriveSpecifierFromVersionPlan(
+        projectLogger,
+        releaseGroup,
+        projectGraphNode,
+        currentVersion
+      );
+      if (bumpType !== "none") {
+        this.#processedVersionPlanFiles.add(versionPlanPath);
+      }
+      return {
+        newVersionInput: bumpType,
+        newVersionInputReason: "VERSION_PLANS",
+        newVersionInputReasonData: {
+          versionPlanPath
+        }
+      };
+    }
+    const versionActions = this.#getVersionActionsForProject(projectName);
+    if (versionActions instanceof NOOP_VERSION_ACTIONS) {
+      return {
+        newVersionInput: "none",
+        newVersionInputReason: "NOOP_VERSION_ACTIONS",
+        newVersionInputReasonData: {}
+      };
+    }
+    throw new Error(
+      `Unhandled version bump config, please report this as a bug on https://github.com/nrwl/nx/issues`
+    );
+  }
+  #getProjectLoggerForProject(projectName) {
+    const projectLogger = this.#releaseGraph.projectLoggers.get(projectName);
+    if (!projectLogger) {
+      throw new Error(
+        `No project logger found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`
+      );
+    }
+    return projectLogger;
+  }
+};
 
 // src/release/release-client.ts
 var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
@@ -3327,24 +4193,66 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
     if (!workspaceConfig) {
       workspaceConfig = await getWorkspaceConfig();
     }
-    let projectGraph;
-    try {
-      projectGraph = readCachedProjectGraph$1();
-    } catch {
-      projectGraph = await createProjectGraphAsync$2({
-        exitOnError: true,
-        resetDaemonClient: true
-      });
-    }
+    const projectGraph = await createProjectGraphAsync$2({
+      exitOnError: true,
+      resetDaemonClient: true
+    });
     if (!projectGraph) {
       throw new Error(
         "Failed to load the project graph. Please run `nx reset`, then run the `storm-git commit` command again."
       );
     }
+    let nxJson;
+    if (!ignoreNxJsonConfig && existsSync(joinPaths(workspaceConfig.workspaceRoot, "nx.json"))) {
+      nxJson = readNxJson();
+    }
+    const config5 = defu(
+      {
+        changelog: {
+          renderOptions: {
+            workspaceConfig
+          }
+        }
+      },
+      {
+        groups: getReleaseGroupConfig(
+          projectGraph,
+          releaseConfig,
+          workspaceConfig
+        )
+      },
+      {
+        groups: getReleaseGroupConfig(
+          projectGraph,
+          nxJson.release ?? {},
+          workspaceConfig
+        )
+      },
+      omit(releaseConfig, ["groups"]),
+      nxJson.release ? omit(nxJson.release, ["groups"]) : {},
+      omit(DEFAULT_RELEASE_CONFIG, ["groups"])
+    );
+    const normalizedConfig = clone(config5);
+    if (workspaceConfig.preid) {
+      normalizedConfig.groups = Object.fromEntries(
+        Object.entries(normalizedConfig.groups ?? {}).map(([name, group]) => {
+          return [
+            name,
+            {
+              ...group,
+              version: {
+                ...group.version,
+                preid: workspaceConfig.preid
+              }
+            }
+          ];
+        })
+      );
+    }
     return new _StormReleaseClient(
       projectGraph,
-      releaseConfig,
-      ignoreNxJsonConfig,
+      config5,
+      normalizedConfig,
       workspaceConfig
     );
   }
@@ -3352,6 +4260,10 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
    * The release configuration used by this release client.
    */
   config;
+  /**
+   * The normalized release configuration used by this release client.
+   */
+  normalizedConfig;
   /**
    * The workspace configuration used by this release client.
    */
@@ -3376,40 +4288,16 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
    * @param ignoreNxJsonConfig - Whether to ignore the nx.json configuration and use only the provided {@link releaseConfig}. Default is false.
    * @param workspaceConfig - Optional Storm workspace configuration object for logging purposes.
    */
-  constructor(projectGraph, releaseConfig, ignoreNxJsonConfig, workspaceConfig) {
-    let nxJson;
-    if (!ignoreNxJsonConfig && existsSync(joinPaths(workspaceConfig.workspaceRoot, "nx.json"))) {
-      nxJson = readNxJson();
-    }
-    const config5 = defu(
-      {
-        changelog: {
-          renderOptions: {
-            workspaceConfig
-          }
-        }
-      },
-      {
-        groups: getReleaseGroupConfig(releaseConfig, workspaceConfig)
-      },
-      {
-        groups: getReleaseGroupConfig(
-          nxJson.release ?? {},
-          workspaceConfig
-        )
-      },
-      omit(releaseConfig, ["groups"]),
-      nxJson.release ? omit(nxJson.release, ["groups"]) : {},
-      omit(DEFAULT_RELEASE_CONFIG, ["groups"])
-    );
-    super(config5, true);
+  constructor(projectGraph, config5, normalizedConfig, workspaceConfig) {
+    super(normalizedConfig, true);
     writeDebug(
       "Executing release with the following configuration",
       workspaceConfig
     );
-    writeDebug(config5, workspaceConfig);
+    writeDebug(normalizedConfig, workspaceConfig);
     this.projectGraph = projectGraph;
     this.config = config5;
+    this.normalizedConfig = normalizedConfig;
     this.workspaceConfig = workspaceConfig;
     this.tree = new FsTree(workspaceConfig.workspaceRoot, false);
     this.projectConfigurations = readProjectsConfigurationFromProjectGraph$2(projectGraph);
@@ -3425,8 +4313,19 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
         v.newVersion ? extractPreid(v.newVersion) : void 0
       ])
     );
+    const releaseGraph = options.releaseGraph ?? await createReleaseGraph({
+      tree: this.tree,
+      projectGraph: this.projectGraph,
+      nxReleaseConfig: this.normalizedConfig,
+      filters: {
+        projects: options.projects,
+        groups: options.groups
+      },
+      firstRelease: !!options.firstRelease,
+      verbose: isVerbose(this.workspaceConfig.logLevel)
+    });
     const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
-    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+    for (const releaseGroup of releaseGraph.releaseGroups) {
       if (releaseGroup.projectsRelationship !== "independent") {
         continue;
       }
@@ -3454,12 +4353,12 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
       }
     }
     const allProjectChangelogs = {};
-    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+    for (const releaseGroup of releaseGraph.releaseGroups) {
       const config5 = releaseGroup.changelog;
       if (config5 === false) {
         continue;
       }
-      if (!options.releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
+      if (!releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
         throw new Error(
           `No filtered projects found for release group ${releaseGroup.name}`
         );
@@ -3468,9 +4367,7 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
         // If the user has passed a list of projects, we need to use the filtered list of projects within the release group, plus any dependents
         Array.from(
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          options.releaseGraph.releaseGroupToFilteredProjects.get(
-            releaseGroup
-          )
+          releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup)
         ).flatMap((project) => {
           return [
             project,
@@ -3493,9 +4390,10 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
               projectName: project.name,
               releaseGroupName: releaseGroup.name
             },
+            releaseGraph.resolveRepositoryTags.bind(releaseGraph),
             {
               checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
-              preid: projectsPreid[project.name],
+              preid: projectsPreid[project.name] || this.workspaceConfig.preid,
               requireSemver: releaseGroup.releaseTag.requireSemver,
               strictPreid: releaseGroup.releaseTag.strictPreid
             }
@@ -3549,7 +4447,7 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
                 fileMap.nonProjectFiles
               ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
             })),
-            this.config.conventionalCommits
+            this.normalizedConfig.conventionalCommits
           );
           writeDebug(
             `Running changelog generation for the ${releaseGroup.name} release group`,
@@ -3583,12 +4481,15 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
         let changes = [];
         let fromRef = options.from || (await getLatestGitTagForPattern(
           releaseGroup.releaseTag.pattern,
-          {},
+          {
+            releaseGroupName: releaseGroup.name
+          },
+          releaseGraph.resolveRepositoryTags.bind(releaseGraph),
           {
             checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
-            preid: Object.keys(projectsPreid)[0] ? projectsPreid?.[Object.keys(projectsPreid)[0]] : void 0,
+            preid: Object.keys(projectsPreid)[0] && projectsPreid?.[Object.keys(projectsPreid)[0]] ? projectsPreid?.[Object.keys(projectsPreid)[0]] : this.workspaceConfig.preid,
             requireSemver: releaseGroup.releaseTag.requireSemver,
-            strictPreid: releaseGroup.releaseTag.strictPreid
+            strictPreid: releaseGroup.releaseTag.strictPreid || this.workspaceConfig.preid !== void 0
           }
         ))?.tag;
         if (!fromRef) {
@@ -3620,7 +4521,7 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
               fileMap.nonProjectFiles
             ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
           })),
-          this.config.conventionalCommits
+          this.normalizedConfig.conventionalCommits
         );
         writeDebug(
           `Running changelog generation for the ${releaseGroup.name} release group`,
@@ -3676,7 +4577,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       options.releaseGraph.releaseGroups,
       options.releaseGraph.releaseGroupToFilteredProjects,
       options.versionData,
-      options.gitCommitMessage || this.config.changelog?.git?.commitMessage || "release(monorepo): Publish workspace release updates"
+      options.gitCommitMessage || this.normalizedConfig.changelog?.git?.commitMessage || DEFAULT_COMMIT_MESSAGE
     );
     const changes = this.tree.listChanges();
     if (!changes.length) {
@@ -3699,7 +4600,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       isDryRun: !!options.dryRun,
       isVerbose: !!options.verbose,
       gitCommitMessages: commitMessageValues,
-      gitCommitArgs: options.gitCommitArgs || this.config.changelog?.git?.commitArgs
+      gitCommitArgs: options.gitCommitArgs || this.normalizedConfig.changelog?.git?.commitArgs
     });
     latestCommit = await getCommitHash("HEAD");
     writeDebug(
@@ -3709,8 +4610,8 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
     for (const tag of gitTagValues) {
       await gitTag({
         tag,
-        message: options.gitTagMessage || this.config.changelog?.git?.tagMessage,
-        additionalArgs: options.gitTagArgs || this.config.changelog?.git?.tagArgs,
+        message: options.gitTagMessage || this.normalizedConfig.changelog?.git?.tagMessage,
+        additionalArgs: options.gitTagArgs || this.normalizedConfig.changelog?.git?.tagArgs,
         dryRun: options.dryRun,
         verbose: options.verbose
       });
@@ -3723,13 +4624,323 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       gitRemote: options.gitRemote,
       dryRun: options.dryRun,
       verbose: options.verbose,
-      additionalArgs: options.gitPushArgs || this.config.changelog?.git?.pushArgs
+      additionalArgs: options.gitPushArgs || this.normalizedConfig.changelog?.git?.pushArgs
     });
     for (const postGitTask of postGitTasks) {
       await postGitTask(latestCommit);
     }
     return;
   };
+  releaseVersion = async (options) => {
+    const verbose = options.verbose || isVerbose(this.workspaceConfig.logLevel);
+    this.projectGraph = await createProjectGraphAsync$2({
+      exitOnError: true,
+      resetDaemonClient: true
+    });
+    if (!this.projectGraph) {
+      throw new Error(
+        "Failed to load the project graph. Please run `nx reset`, then run the `storm-git commit` command again."
+      );
+    }
+    const releaseGraph = options.releaseGraph ?? await createReleaseGraph({
+      tree: this.tree,
+      projectGraph: this.projectGraph,
+      nxReleaseConfig: this.normalizedConfig,
+      filters: {
+        projects: options.projects,
+        groups: options.groups
+      },
+      firstRelease: !!options.firstRelease,
+      verbose,
+      preid: options.preid ?? this.workspaceConfig.preid,
+      versionActionsOptionsOverrides: options.versionActionsOptionsOverrides
+    });
+    if (releaseGraph.filterLog && process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== "true") {
+      writeDebug(formatNxLog(releaseGraph.filterLog), this.workspaceConfig);
+    }
+    if (!options.specifier) {
+      const rawVersionPlans = await readRawVersionPlans();
+      await setResolvedVersionPlansOnGroups(
+        rawVersionPlans,
+        releaseGraph.releaseGroups,
+        Object.keys(this.projectGraph.nodes),
+        verbose
+      );
+      const versionPlanValidationError = validateResolvedVersionPlansAgainstFilter(
+        releaseGraph.releaseGroups,
+        releaseGraph.releaseGroupToFilteredProjects
+      );
+      if (versionPlanValidationError) {
+        throw new Error(formatNxLog(versionPlanValidationError));
+      }
+    } else {
+      if (verbose && releaseGraph.releaseGroups.some((g) => !!g.versionPlans)) {
+        writeDebug(
+          `Skipping version plan discovery as a specifier was provided`,
+          this.workspaceConfig
+        );
+      }
+    }
+    if (options.deleteVersionPlans === void 0) {
+      options.deleteVersionPlans = false;
+    }
+    if (this.normalizedConfig.version?.preVersionCommand) {
+      writeDebug(
+        "Executing the following pre-version command: \n" + this.normalizedConfig.version.preVersionCommand,
+        this.workspaceConfig
+      );
+      try {
+        const childProcess2 = runAsync(
+          this.workspaceConfig,
+          this.normalizedConfig.version.preVersionCommand,
+          this.workspaceConfig.workspaceRoot,
+          {
+            ...process.env,
+            NX_DRY_RUN: options.dryRun ? "true" : "false"
+          }
+        );
+        if (options.verbose) {
+          childProcess2.stdout?.pipe(process.stdout);
+          childProcess2.stderr?.pipe(process.stderr);
+        }
+        await childProcess2;
+      } catch (e) {
+        throw new Error(
+          formatNxLog({
+            title: `The pre-version command failed. See the full output above.`,
+            bodyLines: [this.normalizedConfig.version.preVersionCommand, e]
+          })
+        );
+      }
+    }
+    for (const groupName of releaseGraph.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph.releaseGroups.find(
+        (g) => g.name === groupName
+      );
+      if (!releaseGroup) {
+        continue;
+      }
+      if (releaseGroup.version?.groupPreVersionCommand) {
+        writeDebug(
+          `Executing the ${releaseGroup.name} release group's pre-version command: 
+` + releaseGroup.version?.groupPreVersionCommand,
+          this.workspaceConfig
+        );
+        try {
+          const childProcess2 = runAsync(
+            this.workspaceConfig,
+            releaseGroup.version?.groupPreVersionCommand,
+            this.workspaceConfig.workspaceRoot,
+            {
+              ...process.env,
+              NX_DRY_RUN: options.dryRun ? "true" : "false"
+            }
+          );
+          if (options.verbose) {
+            childProcess2.stdout?.pipe(process.stdout);
+            childProcess2.stderr?.pipe(process.stderr);
+          }
+          await childProcess2;
+        } catch (e) {
+          throw new Error(
+            formatNxLog({
+              title: `The ${releaseGroup.name} release group's pre-version command failed. See the full output above.`,
+              bodyLines: [releaseGroup.version?.groupPreVersionCommand, e]
+            })
+          );
+        }
+      }
+    }
+    await releaseGraph.validate(this.tree);
+    const commitMessage = options.gitCommitMessage || this.normalizedConfig.version?.git?.commitMessage;
+    const additionalChangedFiles = /* @__PURE__ */ new Set();
+    const additionalDeletedFiles = /* @__PURE__ */ new Set();
+    const processor = new StormReleaseGroupProcessor(
+      this.tree,
+      this.workspaceConfig,
+      this.projectGraph,
+      this.normalizedConfig,
+      releaseGraph,
+      options
+    );
+    try {
+      await processor.processGroups();
+      if (options.deleteVersionPlans) {
+        processor.deleteProcessedVersionPlanFiles();
+      }
+    } catch (err) {
+      processor.flushAllProjectLoggers();
+      throw err;
+    }
+    await formatChangedFiles(this.tree);
+    printAndFlushChanges(this.tree, !!options.dryRun);
+    const { changedFiles: changed, deletedFiles: deleted } = await processor.afterAllProjectsVersioned({
+      ...this.normalizedConfig.version.versionActionsOptions,
+      ...options.versionActionsOptionsOverrides ?? {}
+    });
+    changed.forEach((f) => additionalChangedFiles.add(f));
+    deleted.forEach((f) => additionalDeletedFiles.add(f));
+    if (this.normalizedConfig.docker && typeof this.normalizedConfig.docker === "object" && this.normalizedConfig.docker?.preVersionCommand) {
+      writeDebug(
+        `Executing the docker pre-version command: 
+` + this.normalizedConfig.docker.preVersionCommand,
+        this.workspaceConfig
+      );
+      try {
+        const childProcess2 = runAsync(
+          this.workspaceConfig,
+          this.normalizedConfig.docker.preVersionCommand,
+          this.workspaceConfig.workspaceRoot,
+          {
+            ...process.env,
+            NX_DRY_RUN: options.dryRun ? "true" : "false"
+          }
+        );
+        if (options.verbose) {
+          childProcess2.stdout?.pipe(process.stdout);
+          childProcess2.stderr?.pipe(process.stderr);
+        }
+        await childProcess2;
+      } catch (e) {
+        throw new Error(
+          formatNxLog({
+            title: `The docker pre-version command failed. See the full output above.`,
+            bodyLines: [this.normalizedConfig.docker.preVersionCommand, e]
+          })
+        );
+      }
+    }
+    for (const groupName of releaseGraph.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph.releaseGroups.find(
+        (g) => g.name === groupName
+      );
+      if (!releaseGroup) {
+        continue;
+      }
+      if (releaseGroup.docker?.groupPreVersionCommand) {
+        writeDebug(
+          `Executing the ${releaseGroup.name} release group's docker pre-version command: 
+` + releaseGroup.docker?.groupPreVersionCommand,
+          this.workspaceConfig
+        );
+        try {
+          const childProcess2 = runAsync(
+            this.workspaceConfig,
+            releaseGroup.docker?.groupPreVersionCommand,
+            this.workspaceConfig.workspaceRoot,
+            {
+              ...process.env,
+              NX_DRY_RUN: options.dryRun ? "true" : "false"
+            }
+          );
+          if (options.verbose) {
+            childProcess2.stdout?.pipe(process.stdout);
+            childProcess2.stderr?.pipe(process.stderr);
+          }
+          await childProcess2;
+        } catch (e) {
+          throw new Error(
+            formatNxLog({
+              title: `The ${releaseGroup.name} release group's docker pre-version command failed. See the full output above.`,
+              bodyLines: [releaseGroup.docker?.groupPreVersionCommand, e]
+            })
+          );
+        }
+      }
+    }
+    if (this.normalizedConfig.docker || releaseGraph.releaseGroups.some((rg) => rg.docker)) {
+      writeWarning(
+        formatNxLog({
+          title: "Warning",
+          bodyLines: [
+            `Docker support is experimental. Breaking changes may occur and not adhere to semver versioning.`
+          ]
+        })
+      );
+    }
+    await processor.processDockerProjects(
+      options.dockerVersionScheme,
+      options.dockerVersion
+    );
+    const versionData = processor.getVersionData();
+    const gitTagValues = options.gitTag ?? this.normalizedConfig.version?.git?.tag ? createGitTagValues(
+      releaseGraph.releaseGroups,
+      releaseGraph.releaseGroupToFilteredProjects,
+      versionData
+    ) : [];
+    handleDuplicateGitTags(gitTagValues);
+    let workspaceVersion = void 0;
+    if (releaseGraph.releaseGroups.length === 1) {
+      const releaseGroup = releaseGraph.releaseGroups[0];
+      if (releaseGroup?.projectsRelationship === "fixed") {
+        const releaseGroupProjectNames = Array.from(
+          releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup)
+        );
+        workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion;
+      }
+    }
+    const changedFiles = [
+      ...this.tree.listChanges().map((f) => f.path),
+      ...additionalChangedFiles
+    ];
+    const deletedFiles = Array.from(additionalDeletedFiles);
+    if (!changedFiles.length && !deletedFiles.length) {
+      return {
+        workspaceVersion,
+        projectsVersionData: versionData,
+        releaseGraph
+      };
+    }
+    if (options.gitCommit ?? this.normalizedConfig.version?.git?.commit) {
+      await commitChanges({
+        changedFiles,
+        deletedFiles,
+        isDryRun: !!options.dryRun,
+        isVerbose: !!options.verbose,
+        gitCommitMessages: createCommitMessageValues(
+          releaseGraph.releaseGroups,
+          releaseGraph.releaseGroupToFilteredProjects,
+          versionData,
+          commitMessage
+        ),
+        gitCommitArgs: options.gitCommitArgs || this.normalizedConfig.version?.git?.commitArgs
+      });
+    } else if (options.stageChanges ?? this.normalizedConfig.version?.git?.stageChanges) {
+      writeDebug(`Staging changed files with git`);
+      await gitAdd({
+        changedFiles,
+        deletedFiles,
+        dryRun: options.dryRun,
+        verbose
+      });
+    }
+    if (options.gitTag ?? this.normalizedConfig.version?.git?.tag) {
+      writeDebug(`Tagging commit with git`);
+      for (const tag of gitTagValues) {
+        await gitTag({
+          tag,
+          message: options.gitTagMessage || this.normalizedConfig.version?.git?.tagMessage,
+          additionalArgs: options.gitTagArgs || this.normalizedConfig.version?.git?.tagArgs,
+          dryRun: options.dryRun,
+          verbose: options.verbose
+        });
+      }
+    }
+    if (options.gitPush ?? this.normalizedConfig.version?.git?.push) {
+      writeDebug(`Pushing to git remote "${options.gitRemote ?? "origin"}"`);
+      await gitPush({
+        gitRemote: options.gitRemote,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        additionalArgs: options.gitPushArgs || this.normalizedConfig.version?.git?.pushArgs
+      });
+    }
+    return {
+      workspaceVersion,
+      projectsVersionData: versionData,
+      releaseGraph
+    };
+  };
 };
 
 // src/release/run.ts