@storm-software/git-tools 2.130.40 → 2.131.7

package/bin/git.cjs

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 'use strict';
 
-var chunkTHX6DU6T_cjs = require('./chunk-THX6DU6T.cjs');
-var chunkLR2WNL25_cjs = require('./chunk-LR2WNL25.cjs');
-var chunk27LFN4VQ_cjs = require('./chunk-27LFN4VQ.cjs');
-var chunkUIGOGTUM_cjs = require('./chunk-UIGOGTUM.cjs');
-require('./chunk-USGU6ZVC.cjs');
-var chunkMY767YV7_cjs = require('./chunk-MY767YV7.cjs');
+var chunkDPKFBB3S_cjs = require('./chunk-DPKFBB3S.cjs');
+var chunkOGGY5I23_cjs = require('./chunk-OGGY5I23.cjs');
+var chunkRZNFHUM6_cjs = require('./chunk-RZNFHUM6.cjs');
+var chunkAQ5YHZ3Z_cjs = require('./chunk-AQ5YHZ3Z.cjs');
+require('./chunk-POFLIQQB.cjs');
+var chunkW5P2IM2W_cjs = require('./chunk-W5P2IM2W.cjs');
 require('./chunk-YHZNDNCW.cjs');
-var chunkROM64JTJ_cjs = require('./chunk-ROM64JTJ.cjs');
-var chunkFH5OSXAJ_cjs = require('./chunk-FH5OSXAJ.cjs');
-var chunkPTYTYIPG_cjs = require('./chunk-PTYTYIPG.cjs');
+var chunk4EOHM2UV_cjs = require('./chunk-4EOHM2UV.cjs');
+var chunkMTAYUS7E_cjs = require('./chunk-MTAYUS7E.cjs');
+var chunk4ILBJTRR_cjs = require('./chunk-4ILBJTRR.cjs');
 var TOML = require('@ltd/j-toml');
 var commander = require('commander');
 require('@inquirer/checkbox');
@@ -54,12 +54,24 @@ var utils = require('nx/src/tasks-runner/utils');
 var execCommand_js = require('nx/src/command-line/release/utils/exec-command.js');
 var git = require('nx/src/command-line/release/utils/git');
 var semver = require('semver');
+var clone = require('nanoclone');
 var release = require('nx/release');
+var versionPlans = require('nx/src/command-line/release/config/version-plans');
+var printChanges_js = require('nx/src/command-line/release/utils/print-changes.js');
+var releaseGraph = require('nx/src/command-line/release/utils/release-graph');
+var versionPlanUtils = require('nx/src/command-line/release/utils/version-plan-utils');
 var nxJson = require('nx/src/config/nx-json');
 var tree = require('nx/src/generators/tree');
 var fileMapUtils = require('nx/src/project-graph/file-map-utils');
+var importsPlugin = require('prettier-plugin-organize-imports');
 var DefaultChangelogRenderer = require('nx/release/changelog-renderer');
 var conventionalCommits = require('nx/src/command-line/release/config/conventional-commits');
+var findMatchingProjects = require('nx/src/utils/find-matching-projects');
+var config_js = require('nx/src/command-line/release/config/config.js');
+var deriveSpecifierFromConventionalCommits = require('nx/src/command-line/release/version/derive-specifier-from-conventional-commits');
+var deriverSpecifierFromVersionPlans = require('nx/src/command-line/release/version/deriver-specifier-from-version-plans');
+var releaseGroupProcessor = require('nx/src/command-line/release/version/release-group-processor');
+var versionActions_js = require('nx/src/command-line/release/version/version-actions.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -81,6 +93,9 @@ var ___default = /*#__PURE__*/_interopDefault(_);
 var updateSection__default = /*#__PURE__*/_interopDefault(updateSection);
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var semver__default = /*#__PURE__*/_interopDefault(semver);
+var clone__default = /*#__PURE__*/_interopDefault(clone);
+var importsPlugin__default = /*#__PURE__*/_interopDefault(importsPlugin);
 var DefaultChangelogRenderer__default = /*#__PURE__*/_interopDefault(DefaultChangelogRenderer);
 
 function parseCargoToml(cargoString) {
@@ -409,9 +424,9 @@ function getRuleFromScopeEnum(scopeEnum) {
 
 // ../conventional-changelog/src/index.ts
 async function createPreset(variant = "monorepo") {
-  const workspaceConfig = await chunkPTYTYIPG_cjs.getWorkspaceConfig();
+  const workspaceConfig = await chunk4ILBJTRR_cjs.getWorkspaceConfig();
   if (variant === "minimal") {
-    return chunkPTYTYIPG_cjs.defu(
+    return chunk4ILBJTRR_cjs.defu(
       await createBasePreset__default.default({ ...COMMIT_CONFIGS.minimal.changelogs.props }),
       {
         ...COMMIT_CONFIGS.minimal,
@@ -425,7 +440,7 @@ async function createPreset(variant = "monorepo") {
     );
   }
   const nxScopes = await getNxScopes({ config: workspaceConfig });
-  return chunkPTYTYIPG_cjs.defu(
+  return chunk4ILBJTRR_cjs.defu(
     await createBasePreset__default.default({
       ...COMMIT_CONFIGS.monorepo.changelogs.props,
       scope: nxScopes
@@ -989,7 +1004,7 @@ async function lint(message, config5) {
 // src/commitlint/run.ts
 var COMMIT_EDITMSG_PATH = ".git/COMMIT_EDITMSG";
 async function runCommitLint(workspaceConfig, options) {
-  chunkPTYTYIPG_cjs.writeInfo(
+  chunk4ILBJTRR_cjs.writeInfo(
     "\u{1F4DD} Validating git commit message aligns with the Storm Software specification",
     workspaceConfig
   );
@@ -997,7 +1012,7 @@ async function runCommitLint(workspaceConfig, options) {
   if (options.message && options.message !== COMMIT_EDITMSG_PATH) {
     commitMessage = options.message;
   } else {
-    const commitFile = chunkPTYTYIPG_cjs.joinPaths(
+    const commitFile = chunk4ILBJTRR_cjs.joinPaths(
       workspaceConfig.workspaceRoot,
       options.file || options.message || COMMIT_EDITMSG_PATH
     );
@@ -1014,17 +1029,17 @@ async function runCommitLint(workspaceConfig, options) {
     if (upstreamRemote) {
       const upstreamRemoteIdentifier = upstreamRemote.split("	")[0]?.trim();
       if (!upstreamRemoteIdentifier) {
-        chunkPTYTYIPG_cjs.writeWarning(
+        chunk4ILBJTRR_cjs.writeWarning(
           `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison.`,
           workspaceConfig
         );
         return;
       }
-      chunkPTYTYIPG_cjs.writeDebug(`Comparing against remote ${upstreamRemoteIdentifier}`);
+      chunk4ILBJTRR_cjs.writeDebug(`Comparing against remote ${upstreamRemoteIdentifier}`);
       const currentBranch = childProcess__default.default.execSync("git branch --show-current").toString().trim();
       gitLogCmd = gitLogCmd + ` ${currentBranch} ^${upstreamRemoteIdentifier}/main`;
     } else {
-      chunkPTYTYIPG_cjs.writeWarning(
+      chunk4ILBJTRR_cjs.writeWarning(
         `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison against upstream main.`,
         workspaceConfig
       );
@@ -1032,7 +1047,7 @@ async function runCommitLint(workspaceConfig, options) {
     }
     commitMessage = childProcess__default.default.execSync(gitLogCmd).toString().trim();
     if (!commitMessage) {
-      chunkPTYTYIPG_cjs.writeWarning(
+      chunk4ILBJTRR_cjs.writeWarning(
         "No commits found. Skipping commit message validation.",
         workspaceConfig
       );
@@ -1042,7 +1057,7 @@ async function runCommitLint(workspaceConfig, options) {
   const preset = await createPreset(workspaceConfig.variant);
   const report = await lint(commitMessage, preset);
   if (!preset.commitlint.regex.test(commitMessage) || report.errors.length || report.warnings.length) {
-    chunkPTYTYIPG_cjs.writeSuccess(
+    chunk4ILBJTRR_cjs.writeSuccess(
       `Commit was processing completed successfully!`,
       workspaceConfig
     );
@@ -1254,7 +1269,7 @@ async function createState(workspaceConfig, configPath) {
         const project = projectConfigurations.projects[scope];
         if (project) {
           let description = `${project.name} - ${project.root}`;
-          const packageJsonPath = chunkPTYTYIPG_cjs.joinPaths(project.root, "package.json");
+          const packageJsonPath = chunk4ILBJTRR_cjs.joinPaths(project.root, "package.json");
           if (fs$1.existsSync(packageJsonPath)) {
             const packageJsonFile = await fs.readFile(packageJsonPath, "utf8");
             const packageJson = JSON.parse(packageJsonFile);
@@ -1300,11 +1315,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__default.default(answers.body || "", wrapOptions) : "";
   const breaking = answers.breakingBody && typeof answers.breakingBody === "string" ? wrap__default.default(answers.breakingBody || "", wrapOptions) : "";
   const issues = answers.issuesBody && typeof answers.issuesBody === "string" ? wrap__default.default(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 += `
@@ -1328,20 +1343,20 @@ ${closedIssueEmoji}${config5.settings.closedIssueMessage}${issues}`;
 
 // src/commit/run.ts
 async function runCommit(commitizenFile, dryRun = false) {
-  const workspaceConfig = await chunkPTYTYIPG_cjs.getWorkspaceConfig();
+  const workspaceConfig = await chunk4ILBJTRR_cjs.getWorkspaceConfig();
   const state = await createState(workspaceConfig);
   if (dryRun) {
-    chunkPTYTYIPG_cjs.writeInfo("Running in dry mode.", workspaceConfig);
+    chunk4ILBJTRR_cjs.writeInfo("Running in dry mode.", workspaceConfig);
   }
   console.log(chalkTemplate__default.default`
 {bold.#999999 ----------------------------------------}
 
-{bold.#FFFFFF   ${chunkPTYTYIPG_cjs.brandIcon(workspaceConfig)}  Storm Software Git-Tools - Commit}
+{bold.#FFFFFF   ${chunk4ILBJTRR_cjs.brandIcon(workspaceConfig)}  Storm Software Git-Tools - Commit}
 {#CCCCCC Please provide the requested details below...}
 `);
   state.answers = await askQuestions(state);
   const message = formatCommitMessage(state, workspaceConfig);
-  const commitMsgFile = chunkPTYTYIPG_cjs.joinPaths(getGitDir(), "COMMIT_EDITMSG");
+  const commitMsgFile = chunk4ILBJTRR_cjs.joinPaths(getGitDir(), "COMMIT_EDITMSG");
   console.log(chalkTemplate__default.default`
 {bold.#999999 ----------------------------------------}
 
@@ -1354,14 +1369,14 @@ async function runCommit(commitizenFile, dryRun = false) {
   commandItems.push(...["--file", commitMsgFile]);
   const command = shellescape__default.default(commandItems);
   if (dryRun) {
-    chunkPTYTYIPG_cjs.writeDebug(
+    chunk4ILBJTRR_cjs.writeDebug(
       `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`,
       workspaceConfig
     );
-    chunkPTYTYIPG_cjs.writeDebug(`Message [dry-run]: ${message}`, workspaceConfig);
+    chunk4ILBJTRR_cjs.writeDebug(`Message [dry-run]: ${message}`, workspaceConfig);
   } else {
     await fs__default.default.writeFile(commitMsgFile, message);
-    chunkFH5OSXAJ_cjs.run(workspaceConfig, command);
+    chunkMTAYUS7E_cjs.run(workspaceConfig, command);
   }
 }
 async function askQuestions(state) {
@@ -2010,14 +2025,14 @@ var runReadme = async ({
   project,
   output: output3,
   clean = true,
-  prettier = true,
+  prettier: prettier2 = true,
   workspace = false
 }) => {
   const projectGraph = await projectGraph_js.createProjectGraphAsync({
     exitOnError: true
   });
   const projectConfigs = projectGraph_js.readProjectsConfigurationFromProjectGraph(projectGraph);
-  const workspaceRoot = chunkPTYTYIPG_cjs.findWorkspaceRootSafe(process.cwd());
+  const workspaceRoot = chunk4ILBJTRR_cjs.findWorkspaceRootSafe(process.cwd());
   if (!workspaceRoot) {
     throw new Error(
       "Unable to find the workspace root. Please ensure you are running this command from within a workspace."
@@ -2045,7 +2060,7 @@ var runReadme = async ({
       templates,
       output: output3,
       clean,
-      prettier
+      prettier: prettier2
     });
   } else {
     for (const projectName of Object.keys(projectConfigs.projects)) {
@@ -2053,12 +2068,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 projectGraph_js.createProjectGraphAsync({
     exitOnError: true
   });
@@ -2146,10 +2161,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,
@@ -2434,7 +2449,7 @@ async function generateChangelogContent(releaseVersion, filepath, newContent, cu
   const header = await prettier.format(
     `![${(typeof workspaceConfig?.release.banner === "string" ? workspaceConfig.organization ? titleCase(
       typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization.name
-    ) : void 0 : workspaceConfig?.release.banner.alt) || "Branded release banner image"}](${bannerUrl || chunkPTYTYIPG_cjs.STORM_DEFAULT_RELEASE_BANNER})
+    ) : void 0 : workspaceConfig?.release.banner.alt) || "Branded release banner image"}](${bannerUrl || chunk4ILBJTRR_cjs.STORM_DEFAULT_RELEASE_BANNER})
 
 # Changelog ${project || workspaceConfig?.name ? "for" : ""}${workspaceConfig?.name ? ` ${titleCase(workspaceConfig.name)}` : ""}${project ? `${workspaceConfig?.name ? " -" : ""} ${titleCase(project)}` : ""}
 
@@ -2610,12 +2625,12 @@ async function generateChangelogForProjects({
     projectChangelogs
   )) {
     if (!projectGraph.nodes[projectName]?.data.root) {
-      chunkPTYTYIPG_cjs.writeWarning(
+      chunk4ILBJTRR_cjs.writeWarning(
         `A changelog was generated for ${projectName}, but it could not be found in the project graph. Skipping writing changelog file.`,
         workspaceConfig
       );
     } else if (projectChangelog.contents) {
-      const filePath = chunkPTYTYIPG_cjs.joinPaths(
+      const filePath = chunk4ILBJTRR_cjs.joinPaths(
         projectGraph.nodes[projectName].data.root,
         "CHANGELOG.md"
       );
@@ -2623,7 +2638,7 @@ async function generateChangelogForProjects({
       if (fs$1.existsSync(filePath)) {
         currentContent = await fs.readFile(filePath, "utf8");
       }
-      chunkPTYTYIPG_cjs.writeDebug(
+      chunk4ILBJTRR_cjs.writeDebug(
         `\u270D\uFE0F  Writing changelog for project ${projectName} to ${filePath}`,
         workspaceConfig
       );
@@ -2846,7 +2861,7 @@ var StormGithubRemoteReleaseClient = class extends github.GithubRemoteReleaseCli
   }
   async createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
     if (!this.workspaceConfig) {
-      this.workspaceConfig = await chunkPTYTYIPG_cjs.getWorkspaceConfig();
+      this.workspaceConfig = await chunk4ILBJTRR_cjs.getWorkspaceConfig();
     }
     const name = releaseVersion.gitTag.includes("@") ? releaseVersion.gitTag.replace(new RegExp(`^@${this.workspaceConfig.name}/`), "").replace(/@.*$/, "") : releaseVersion.gitTag;
     return super.createOrUpdateRelease(
@@ -3025,6 +3040,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 prettier.resolveConfig(path);
+    if (resolvedConfig) {
+      code = await prettier.format(
+        data,
+        chunk4ILBJTRR_cjs.defu(
+          {
+            absolutePath: path,
+            ...resolvedConfig
+          },
+          path.endsWith(".ts") || path.endsWith(".tsx") ? { plugins: [importsPlugin__default.default] } : {}
+        )
+      );
+    }
+  } 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__default.default {
   /**
    * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
@@ -3047,7 +3110,7 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer__default.def
   }
   async render() {
     if (!this.workspaceConfig) {
-      this.workspaceConfig = await chunkPTYTYIPG_cjs.getWorkspaceConfig();
+      this.workspaceConfig = await chunk4ILBJTRR_cjs.getWorkspaceConfig();
     }
     return super.render();
   }
@@ -3228,38 +3291,112 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer__default.def
   }
 };
 
-// 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_INDEPENDENT_RELEASE_TAG_PATTERN,
+    preferDockerVersion: false
   },
-  releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
+  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",
@@ -3275,10 +3412,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",
@@ -3290,49 +3424,132 @@ 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: chunk4ILBJTRR_cjs.defu(
+      {
+        projects: ["packages/*"]
+      },
+      DEFAULT_JS_RELEASE_GROUP_CONFIG,
+      DEFAULT_RELEASE_GROUP_CONFIG
+    ),
+    crates: chunk4ILBJTRR_cjs.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 chunk4ILBJTRR_cjs.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 = chunkPTYTYIPG_cjs.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.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 && fs$1.existsSync(
+          chunk4ILBJTRR_cjs.joinPaths(
+            projectGraph.nodes[project]?.data.metadata?.root,
+            "package.json"
+          )
+        ))
+      )) {
+        languageDefaultConfig = chunk4ILBJTRR_cjs.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 && fs$1.existsSync(
+          chunk4ILBJTRR_cjs.joinPaths(
+            projectGraph.nodes[project]?.data.metadata?.root,
+            "Cargo.toml"
+          )
+        ))
+      )) {
+        languageDefaultConfig = chunk4ILBJTRR_cjs.defu(
+          DEFAULT_RUST_RELEASE_GROUP_CONFIG,
+          DEFAULT_RELEASE_GROUP_CONFIG
+        );
+      }
+      const config5 = mergeReleaseGroupConfig(
+        group,
+        chunk4ILBJTRR_cjs.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 = chunkPTYTYIPG_cjs.joinPaths(
+          config5.changelog.renderer = chunk4ILBJTRR_cjs.joinPaths(
             workspaceConfig.workspaceRoot,
             config5.changelog.renderer
           );
         }
         if (config5.version?.versionActions && config5.version.versionActions.startsWith("./")) {
-          config5.version.versionActions = chunkPTYTYIPG_cjs.joinPaths(
+          config5.version.versionActions = chunk4ILBJTRR_cjs.joinPaths(
             workspaceConfig.workspaceRoot,
             config5.version?.versionActions
           );
@@ -3342,31 +3559,725 @@ function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
     })
   );
 }
+var StormReleaseGroupProcessor = class extends releaseGroupProcessor.ReleaseGroupProcessor {
+  constructor(tree, workspaceConfig, projectGraph, nxReleaseConfig, releaseGraph, versionOptions) {
+    super(tree, projectGraph, nxReleaseConfig, releaseGraph, {
+      dryRun: !!versionOptions.dryRun,
+      verbose: versionOptions.verbose || chunk4ILBJTRR_cjs.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 || chunk4ILBJTRR_cjs.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 } = chunk4ILBJTRR_cjs.__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__default.default.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__default.default.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 !== config_js.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.deriveSpecifierFromConventionalCommits(
+        {
+          ...this.#nxReleaseConfig,
+          git: this.#nxReleaseConfig.git ?? {}
+        },
+        this.#projectGraph,
+        projectLogger,
+        releaseGroup,
+        projectGraphNode,
+        !!semver__default.default.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 deriverSpecifierFromVersionPlans.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 versionActions_js.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 release.ReleaseClient {
   static async create(releaseConfig = {}, ignoreNxJsonConfig = false, workspaceConfig) {
     if (!workspaceConfig) {
-      workspaceConfig = await chunkPTYTYIPG_cjs.getWorkspaceConfig();
-    }
-    let projectGraph;
-    try {
-      projectGraph = devkit.readCachedProjectGraph();
-    } catch {
-      projectGraph = await devkit.createProjectGraphAsync({
-        exitOnError: true,
-        resetDaemonClient: true
-      });
+      workspaceConfig = await chunk4ILBJTRR_cjs.getWorkspaceConfig();
     }
+    const projectGraph = await devkit.createProjectGraphAsync({
+      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$1;
+    if (!ignoreNxJsonConfig && fs$1.existsSync(chunk4ILBJTRR_cjs.joinPaths(workspaceConfig.workspaceRoot, "nx.json"))) {
+      nxJson$1 = nxJson.readNxJson();
+    }
+    const config5 = chunk4ILBJTRR_cjs.defu(
+      {
+        changelog: {
+          renderOptions: {
+            workspaceConfig
+          }
+        }
+      },
+      {
+        groups: getReleaseGroupConfig(
+          projectGraph,
+          releaseConfig,
+          workspaceConfig
+        )
+      },
+      {
+        groups: getReleaseGroupConfig(
+          projectGraph,
+          nxJson$1.release ?? {},
+          workspaceConfig
+        )
+      },
+      omit(releaseConfig, ["groups"]),
+      nxJson$1.release ? omit(nxJson$1.release, ["groups"]) : {},
+      omit(DEFAULT_RELEASE_CONFIG, ["groups"])
+    );
+    const normalizedConfig = clone__default.default(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
     );
   }
@@ -3374,6 +4285,10 @@ var StormReleaseClient = class _StormReleaseClient extends release.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.
    */
@@ -3398,40 +4313,16 @@ var StormReleaseClient = class _StormReleaseClient extends release.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$1;
-    if (!ignoreNxJsonConfig && fs$1.existsSync(chunkPTYTYIPG_cjs.joinPaths(workspaceConfig.workspaceRoot, "nx.json"))) {
-      nxJson$1 = nxJson.readNxJson();
-    }
-    const config5 = chunkPTYTYIPG_cjs.defu(
-      {
-        changelog: {
-          renderOptions: {
-            workspaceConfig
-          }
-        }
-      },
-      {
-        groups: getReleaseGroupConfig(releaseConfig, workspaceConfig)
-      },
-      {
-        groups: getReleaseGroupConfig(
-          nxJson$1.release ?? {},
-          workspaceConfig
-        )
-      },
-      omit(releaseConfig, ["groups"]),
-      nxJson$1.release ? omit(nxJson$1.release, ["groups"]) : {},
-      omit(DEFAULT_RELEASE_CONFIG, ["groups"])
-    );
-    super(config5, true);
-    chunkPTYTYIPG_cjs.writeDebug(
+  constructor(projectGraph, config5, normalizedConfig, workspaceConfig) {
+    super(normalizedConfig, true);
+    chunk4ILBJTRR_cjs.writeDebug(
       "Executing release with the following configuration",
       workspaceConfig
     );
-    chunkPTYTYIPG_cjs.writeDebug(config5, workspaceConfig);
+    chunk4ILBJTRR_cjs.writeDebug(normalizedConfig, workspaceConfig);
     this.projectGraph = projectGraph;
     this.config = config5;
+    this.normalizedConfig = normalizedConfig;
     this.workspaceConfig = workspaceConfig;
     this.tree = new tree.FsTree(workspaceConfig.workspaceRoot, false);
     this.projectConfigurations = devkit.readProjectsConfigurationFromProjectGraph(projectGraph);
@@ -3447,8 +4338,19 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
         v.newVersion ? extractPreid(v.newVersion) : void 0
       ])
     );
+    const releaseGraph$1 = options.releaseGraph ?? await releaseGraph.createReleaseGraph({
+      tree: this.tree,
+      projectGraph: this.projectGraph,
+      nxReleaseConfig: this.normalizedConfig,
+      filters: {
+        projects: options.projects,
+        groups: options.groups
+      },
+      firstRelease: !!options.firstRelease,
+      verbose: chunk4ILBJTRR_cjs.isVerbose(this.workspaceConfig.logLevel)
+    });
     const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
-    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+    for (const releaseGroup of releaseGraph$1.releaseGroups) {
       if (releaseGroup.projectsRelationship !== "independent") {
         continue;
       }
@@ -3476,12 +4378,12 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
       }
     }
     const allProjectChangelogs = {};
-    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+    for (const releaseGroup of releaseGraph$1.releaseGroups) {
       const config5 = releaseGroup.changelog;
       if (config5 === false) {
         continue;
       }
-      if (!options.releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
+      if (!releaseGraph$1.releaseGroupToFilteredProjects.has(releaseGroup)) {
         throw new Error(
           `No filtered projects found for release group ${releaseGroup.name}`
         );
@@ -3490,9 +4392,7 @@ var StormReleaseClient = class _StormReleaseClient extends release.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$1.releaseGroupToFilteredProjects.get(releaseGroup)
         ).flatMap((project) => {
           return [
             project,
@@ -3515,9 +4415,10 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
               projectName: project.name,
               releaseGroupName: releaseGroup.name
             },
+            releaseGraph$1.resolveRepositoryTags.bind(releaseGraph$1),
             {
               checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
-              preid: projectsPreid[project.name],
+              preid: projectsPreid[project.name] || this.workspaceConfig.preid,
               requireSemver: releaseGroup.releaseTag.requireSemver,
               strictPreid: releaseGroup.releaseTag.strictPreid
             }
@@ -3571,9 +4472,9 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
                 fileMap.nonProjectFiles
               ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
             })),
-            this.config.conventionalCommits
+            this.normalizedConfig.conventionalCommits
           );
-          chunkPTYTYIPG_cjs.writeDebug(
+          chunk4ILBJTRR_cjs.writeDebug(
             `Running changelog generation for the ${releaseGroup.name} release group`,
             this.workspaceConfig
           );
@@ -3605,12 +4506,15 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
         let changes = [];
         let fromRef = options.from || (await git.getLatestGitTagForPattern(
           releaseGroup.releaseTag.pattern,
-          {},
+          {
+            releaseGroupName: releaseGroup.name
+          },
+          releaseGraph$1.resolveRepositoryTags.bind(releaseGraph$1),
           {
             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) {
@@ -3642,9 +4546,9 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
               fileMap.nonProjectFiles
             ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
           })),
-          this.config.conventionalCommits
+          this.normalizedConfig.conventionalCommits
         );
-        chunkPTYTYIPG_cjs.writeDebug(
+        chunk4ILBJTRR_cjs.writeDebug(
           `Running changelog generation for the ${releaseGroup.name} release group`,
           this.workspaceConfig
         );
@@ -3673,7 +4577,7 @@ var StormReleaseClient = class _StormReleaseClient extends release.ReleaseClient
         }
       }
     }
-    chunkPTYTYIPG_cjs.writeDebug(
+    chunk4ILBJTRR_cjs.writeDebug(
       `Generated changelogs for ${Object.keys(allProjectChangelogs).length} projects:
 ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
 `,
@@ -3698,11 +4602,11 @@ ${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) {
-      chunkPTYTYIPG_cjs.writeWarning(
+      chunk4ILBJTRR_cjs.writeWarning(
         "No changes were detected for any changelog files, so no changelog entries will be generated.",
         this.workspaceConfig
       );
@@ -3721,23 +4625,23 @@ ${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 git.getCommitHash("HEAD");
-    chunkPTYTYIPG_cjs.writeDebug(
+    chunk4ILBJTRR_cjs.writeDebug(
       `Creating git tags: ${gitTagValues.join(", ")}`,
       this.workspaceConfig
     );
     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
       });
     }
-    chunkPTYTYIPG_cjs.writeDebug(
+    chunk4ILBJTRR_cjs.writeDebug(
       `Pushing to git remote "${options.gitRemote ?? "origin"}"`,
       this.workspaceConfig
     );
@@ -3745,13 +4649,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 || chunk4ILBJTRR_cjs.isVerbose(this.workspaceConfig.logLevel);
+    this.projectGraph = await devkit.createProjectGraphAsync({
+      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$1 = options.releaseGraph ?? await releaseGraph.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$1.filterLog && process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== "true") {
+      chunk4ILBJTRR_cjs.writeDebug(formatNxLog(releaseGraph$1.filterLog), this.workspaceConfig);
+    }
+    if (!options.specifier) {
+      const rawVersionPlans = await versionPlans.readRawVersionPlans();
+      await versionPlans.setResolvedVersionPlansOnGroups(
+        rawVersionPlans,
+        releaseGraph$1.releaseGroups,
+        Object.keys(this.projectGraph.nodes),
+        verbose
+      );
+      const versionPlanValidationError = versionPlanUtils.validateResolvedVersionPlansAgainstFilter(
+        releaseGraph$1.releaseGroups,
+        releaseGraph$1.releaseGroupToFilteredProjects
+      );
+      if (versionPlanValidationError) {
+        throw new Error(formatNxLog(versionPlanValidationError));
+      }
+    } else {
+      if (verbose && releaseGraph$1.releaseGroups.some((g) => !!g.versionPlans)) {
+        chunk4ILBJTRR_cjs.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) {
+      chunk4ILBJTRR_cjs.writeDebug(
+        "Executing the following pre-version command: \n" + this.normalizedConfig.version.preVersionCommand,
+        this.workspaceConfig
+      );
+      try {
+        const childProcess2 = chunkMTAYUS7E_cjs.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$1.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph$1.releaseGroups.find(
+        (g) => g.name === groupName
+      );
+      if (!releaseGroup) {
+        continue;
+      }
+      if (releaseGroup.version?.groupPreVersionCommand) {
+        chunk4ILBJTRR_cjs.writeDebug(
+          `Executing the ${releaseGroup.name} release group's pre-version command: 
+` + releaseGroup.version?.groupPreVersionCommand,
+          this.workspaceConfig
+        );
+        try {
+          const childProcess2 = chunkMTAYUS7E_cjs.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$1.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$1,
+      options
+    );
+    try {
+      await processor.processGroups();
+      if (options.deleteVersionPlans) {
+        processor.deleteProcessedVersionPlanFiles();
+      }
+    } catch (err) {
+      processor.flushAllProjectLoggers();
+      throw err;
+    }
+    await formatChangedFiles(this.tree);
+    printChanges_js.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) {
+      chunk4ILBJTRR_cjs.writeDebug(
+        `Executing the docker pre-version command: 
+` + this.normalizedConfig.docker.preVersionCommand,
+        this.workspaceConfig
+      );
+      try {
+        const childProcess2 = chunkMTAYUS7E_cjs.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$1.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph$1.releaseGroups.find(
+        (g) => g.name === groupName
+      );
+      if (!releaseGroup) {
+        continue;
+      }
+      if (releaseGroup.docker?.groupPreVersionCommand) {
+        chunk4ILBJTRR_cjs.writeDebug(
+          `Executing the ${releaseGroup.name} release group's docker pre-version command: 
+` + releaseGroup.docker?.groupPreVersionCommand,
+          this.workspaceConfig
+        );
+        try {
+          const childProcess2 = chunkMTAYUS7E_cjs.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$1.releaseGroups.some((rg) => rg.docker)) {
+      chunk4ILBJTRR_cjs.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 ? shared.createGitTagValues(
+      releaseGraph$1.releaseGroups,
+      releaseGraph$1.releaseGroupToFilteredProjects,
+      versionData
+    ) : [];
+    shared.handleDuplicateGitTags(gitTagValues);
+    let workspaceVersion = void 0;
+    if (releaseGraph$1.releaseGroups.length === 1) {
+      const releaseGroup = releaseGraph$1.releaseGroups[0];
+      if (releaseGroup?.projectsRelationship === "fixed") {
+        const releaseGroupProjectNames = Array.from(
+          releaseGraph$1.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: releaseGraph$1
+      };
+    }
+    if (options.gitCommit ?? this.normalizedConfig.version?.git?.commit) {
+      await commitChanges({
+        changedFiles,
+        deletedFiles,
+        isDryRun: !!options.dryRun,
+        isVerbose: !!options.verbose,
+        gitCommitMessages: shared.createCommitMessageValues(
+          releaseGraph$1.releaseGroups,
+          releaseGraph$1.releaseGroupToFilteredProjects,
+          versionData,
+          commitMessage
+        ),
+        gitCommitArgs: options.gitCommitArgs || this.normalizedConfig.version?.git?.commitArgs
+      });
+    } else if (options.stageChanges ?? this.normalizedConfig.version?.git?.stageChanges) {
+      chunk4ILBJTRR_cjs.writeDebug(`Staging changed files with git`);
+      await git.gitAdd({
+        changedFiles,
+        deletedFiles,
+        dryRun: options.dryRun,
+        verbose
+      });
+    }
+    if (options.gitTag ?? this.normalizedConfig.version?.git?.tag) {
+      chunk4ILBJTRR_cjs.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) {
+      chunk4ILBJTRR_cjs.writeDebug(`Pushing to git remote "${options.gitRemote ?? "origin"}"`);
+      await git.gitPush({
+        gitRemote: options.gitRemote,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        additionalArgs: options.gitPushArgs || this.normalizedConfig.version?.git?.pushArgs
+      });
+    }
+    return {
+      workspaceVersion,
+      projectsVersionData: versionData,
+      releaseGraph: releaseGraph$1
+    };
+  };
 };
 
 // src/release/run.ts
@@ -3769,7 +4983,7 @@ var runRelease = async (config5, {
     throw new Error("The `GITHUB_ACTOR` environment variable is not set.");
   }
   if (!await isUserAnOrganizationMember(process.env.GITHUB_ACTOR, config5)) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       "You must be a member of the Storm Software organization to run the release process.",
       config5
     );
@@ -3786,26 +5000,26 @@ var runRelease = async (config5, {
   process.env.NODE_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_CONFIG_PROVENANCE = "true";
-  chunkPTYTYIPG_cjs.writeDebug("Creating Storm release client...", config5);
+  chunk4ILBJTRR_cjs.writeDebug("Creating Storm release client...", config5);
   const releaseClient = await StormReleaseClient.create(
     releaseConfig,
     ignoreNxJsonConfig,
     config5
   );
-  chunkPTYTYIPG_cjs.writeDebug("Reading in the workspaces release configuration", config5);
+  chunk4ILBJTRR_cjs.writeDebug("Reading in the workspaces release configuration", config5);
   const to = head || process.env.NX_HEAD;
   const from = base || process.env.NX_BASE;
-  chunkPTYTYIPG_cjs.writeDebug(
+  chunk4ILBJTRR_cjs.writeDebug(
     `Using the following Git SHAs to determine the release content:
  - From: ${from}
  - To: ${to}
 `,
     config5
   );
-  chunkPTYTYIPG_cjs.writeDebug("Determining the current release versions...", config5);
+  chunk4ILBJTRR_cjs.writeDebug("Determining the current release versions...", config5);
   const { workspaceVersion, projectsVersionData, releaseGraph } = await releaseClient.releaseVersion({
     dryRun,
-    verbose: chunkPTYTYIPG_cjs.isVerbose(config5.logLevel),
+    verbose: chunk4ILBJTRR_cjs.isVerbose(config5.logLevel),
     preid: config5.preid,
     stageChanges: true,
     gitCommit: false
@@ -3814,14 +5028,14 @@ var runRelease = async (config5, {
     version: releaseConfig?.projectsRelationship === "fixed" ? workspaceVersion : void 0,
     versionData: projectsVersionData,
     dryRun,
-    verbose: chunkPTYTYIPG_cjs.isVerbose(config5.logLevel),
+    verbose: chunk4ILBJTRR_cjs.isVerbose(config5.logLevel),
     to,
     from,
     releaseGraph
   });
-  chunkPTYTYIPG_cjs.writeDebug("Tagging commit with git", config5);
+  chunk4ILBJTRR_cjs.writeDebug("Tagging commit with git", config5);
   if (skipPublish) {
-    chunkPTYTYIPG_cjs.writeWarning(
+    chunk4ILBJTRR_cjs.writeWarning(
       "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.",
       config5
     );
@@ -3830,7 +5044,7 @@ var runRelease = async (config5, {
       (key) => projectsVersionData[key]?.newVersion
     );
     if (changedProjects.length > 0) {
-      chunkPTYTYIPG_cjs.writeInfo(
+      chunk4ILBJTRR_cjs.writeInfo(
         `Publishing release for ${changedProjects.length} ${changedProjects.length === 1 ? "project" : "projects"}:
 ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
 `,
@@ -3839,7 +5053,7 @@ ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
       await updatePackageManifests(projectsVersionData, config5);
       const result = await releaseClient.releasePublish({
         dryRun,
-        verbose: chunkPTYTYIPG_cjs.isVerbose(config5.logLevel)
+        verbose: chunk4ILBJTRR_cjs.isVerbose(config5.logLevel)
       });
       const failedProjects = Object.keys(result).filter(
         (key) => result[key]?.code && result[key]?.code > 0
@@ -3854,10 +5068,10 @@ ${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${res
         );
       }
     } else {
-      chunkPTYTYIPG_cjs.writeWarning("Skipped publishing packages.", config5);
+      chunk4ILBJTRR_cjs.writeWarning("Skipped publishing packages.", config5);
     }
   }
-  chunkPTYTYIPG_cjs.writeSuccess("Completed the Storm workspace release process!", config5);
+  chunk4ILBJTRR_cjs.writeSuccess("Completed the Storm workspace release process!", config5);
 };
 async function updatePackageManifests(projectsVersionData, config5) {
   let projectGraph;
@@ -3872,7 +5086,7 @@ async function updatePackageManifests(projectsVersionData, config5) {
       Object.keys(projectsVersionData).map(async (node) => {
         const projectNode = projectGraph.nodes[node];
         if (!projectNode?.data.root) {
-          chunkPTYTYIPG_cjs.writeWarning(
+          chunk4ILBJTRR_cjs.writeWarning(
             `Project node ${node} not found in the project graph. Skipping manifest update.`,
             config5
           );
@@ -3880,17 +5094,17 @@ async function updatePackageManifests(projectsVersionData, config5) {
         }
         const versionData = projectsVersionData[node];
         if (projectNode?.data.root && versionData && versionData.newVersion !== null) {
-          chunkPTYTYIPG_cjs.writeTrace(
+          chunk4ILBJTRR_cjs.writeTrace(
             `Writing version ${versionData.newVersion} update to manifest file for ${node}
         `,
             config5
           );
-          const projectRoot = chunkPTYTYIPG_cjs.joinPaths(
+          const projectRoot = chunk4ILBJTRR_cjs.joinPaths(
             config5.workspaceRoot,
             projectNode.data.root
           );
-          const packageJsonPath = chunkPTYTYIPG_cjs.joinPaths(projectRoot, "package.json");
-          const cargoTomlPath = chunkPTYTYIPG_cjs.joinPaths(projectRoot, "Cargo.toml");
+          const packageJsonPath = chunk4ILBJTRR_cjs.joinPaths(projectRoot, "package.json");
+          const cargoTomlPath = chunk4ILBJTRR_cjs.joinPaths(projectRoot, "Cargo.toml");
           if (fs$1.existsSync(packageJsonPath)) {
             const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
             const packageJson = JSON.parse(packageJsonContent);
@@ -3908,7 +5122,7 @@ async function updatePackageManifests(projectsVersionData, config5) {
       })
     );
   } else {
-    chunkPTYTYIPG_cjs.writeWarning("No project nodes found. Skipping manifest updates.", config5);
+    chunk4ILBJTRR_cjs.writeWarning("No project nodes found. Skipping manifest updates.", config5);
   }
 }
 
@@ -3916,8 +5130,8 @@ async function updatePackageManifests(projectsVersionData, config5) {
 var _config = {};
 function createProgram(config5) {
   _config = config5;
-  chunkPTYTYIPG_cjs.writeInfo(`${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running Storm Git Tools`, config5);
-  const root = chunkPTYTYIPG_cjs.findWorkspaceRootSafe(process.cwd());
+  chunk4ILBJTRR_cjs.writeInfo(`${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running Storm Git Tools`, config5);
+  const root = chunk4ILBJTRR_cjs.findWorkspaceRootSafe(process.cwd());
   process.env.STORM_WORKSPACE_ROOT ??= root;
   process.env.NX_WORKSPACE_ROOT_PATH ??= root;
   if (root) {
@@ -3964,12 +5178,12 @@ async function commitAction({
   dryRun = false
 }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(typeof config5 === "string" ? {} : config5)}  Preparing to commit your changes. Please provide the requested details below...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(typeof config5 === "string" ? {} : config5)}  Preparing to commit your changes. Please provide the requested details below...`,
       _config
     );
     await runCommit(config5, dryRun);
-    chunkPTYTYIPG_cjs.writeSuccess(
+    chunk4ILBJTRR_cjs.writeSuccess(
       `\u2714 Storm Commit processing completed successfully!
 
 Note: Please run "pnpm push" to upload these changes to the remote ${_config.name ? _config.name : _config.namespace ? _config.namespace : _config.organization ? _config.organization : "Storm-Software"} Git repository at ${_config.repository}
@@ -3977,7 +5191,7 @@ Note: Please run "pnpm push" to upload these changes to the remote ${_config.nam
       _config
     );
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running commit action: 
 
 ${error.message}${error.stack ? `
@@ -3992,17 +5206,17 @@ Please fix any errors and try committing again.`,
 }
 async function readmeAction(options) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Formatting the workspace's README.md files`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Formatting the workspace's README.md files`,
       _config
     );
     await runReadme(options);
-    chunkPTYTYIPG_cjs.writeSuccess(
+    chunk4ILBJTRR_cjs.writeSuccess(
       "\u2714 Formatting of the workspace's README.md files is complete\n",
       _config
     );
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running README format action: 
 
 ${error.message}`
@@ -4017,8 +5231,8 @@ async function releaseAction({
   dryRun
 }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm Release and Publish process on the workspace`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm Release and Publish process on the workspace`,
       _config
     );
     await runRelease(_config, {
@@ -4027,9 +5241,9 @@ async function releaseAction({
       base,
       head
     });
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Release completed successfully!\n", _config);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Release completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running release action: 
 
 ${error.message} ${error.stack ? `
@@ -4043,17 +5257,17 @@ Stacktrace: ${error.stack}` : ""}`,
 }
 async function commitLintAction(options) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Linting the ${_config.repository ? _config.repository : _config.namespace ? _config.namespace : _config.name ? _config.name : typeof _config.organization === "string" ? _config.organization : _config.organization?.name ? _config.organization?.name : "Storm-Software"} repository's commit messages.`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Linting the ${_config.repository ? _config.repository : _config.namespace ? _config.namespace : _config.name ? _config.name : typeof _config.organization === "string" ? _config.organization : _config.organization?.name ? _config.organization?.name : "Storm-Software"} repository's commit messages.`,
       _config
     );
     await runCommitLint(_config, options);
-    chunkPTYTYIPG_cjs.writeSuccess(
+    chunk4ILBJTRR_cjs.writeSuccess(
       "\u2714 Linting the commit messages completed successfully!\n",
       _config
     );
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while linting the commit messages: 
 
 ${error.message}`,
@@ -4064,14 +5278,14 @@ ${error.message}`,
 }
 async function postCheckoutAction({ files }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm post-checkout git hook for ${files.length} files in the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm post-checkout git hook for ${files.length} files in the workspace...`,
       _config
     );
-    await chunkTHX6DU6T_cjs.postCheckoutHook(_config, files);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Post-checkout hook completed successfully!\n", _config);
+    await chunkDPKFBB3S_cjs.postCheckoutHook(_config, files);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Post-checkout hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the post-checkout hook: 
 
 ${error.message}`,
@@ -4082,14 +5296,14 @@ ${error.message}`,
 }
 async function postCommitAction({ files }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm post-commit git hook for ${files.length} files in the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm post-commit git hook for ${files.length} files in the workspace...`,
       _config
     );
-    await chunkLR2WNL25_cjs.postCommitHook(_config, files);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Post-commit hook completed successfully!\n", _config);
+    await chunkOGGY5I23_cjs.postCommitHook(_config, files);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Post-commit hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the post-commit hook: 
 
 ${error.message}`,
@@ -4100,14 +5314,14 @@ ${error.message}`,
 }
 async function postMergeAction({ files }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm post-merge git hook for ${files.length} files in the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm post-merge git hook for ${files.length} files in the workspace...`,
       _config
     );
-    await chunk27LFN4VQ_cjs.postMergeHook(_config, files);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Post-merge hook completed successfully!\n", _config);
+    await chunkRZNFHUM6_cjs.postMergeHook(_config, files);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Post-merge hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the post-merge hook: 
 
 ${error.message}`,
@@ -4118,14 +5332,14 @@ ${error.message}`,
 }
 async function preCommitAction({ files }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm pre-commit git hook for ${files.length} files in the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm pre-commit git hook for ${files.length} files in the workspace...`,
       _config
     );
-    await chunkUIGOGTUM_cjs.preCommitHook(_config, files);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Pre-commit hook completed successfully!\n", _config);
+    await chunkAQ5YHZ3Z_cjs.preCommitHook(_config, files);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Pre-commit hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the pre-commit hook: 
 
 ${error.message}`,
@@ -4136,14 +5350,14 @@ ${error.message}`,
 }
 async function prePushAction({ files }) {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm pre-push git hook for ${files.length} files in the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm pre-push git hook for ${files.length} files in the workspace...`,
       _config
     );
-    await chunkMY767YV7_cjs.prePushHook(_config, files);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Pre-push hook completed successfully!\n", _config);
+    await chunkW5P2IM2W_cjs.prePushHook(_config, files);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Pre-push hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the pre-push hook: 
 
 ${error.message}`,
@@ -4154,14 +5368,14 @@ ${error.message}`,
 }
 async function prepareAction() {
   try {
-    chunkPTYTYIPG_cjs.writeInfo(
-      `${chunkPTYTYIPG_cjs.brandIcon(_config)}  Running the Storm prepare git hook for the workspace...`,
+    chunk4ILBJTRR_cjs.writeInfo(
+      `${chunk4ILBJTRR_cjs.brandIcon(_config)}  Running the Storm prepare git hook for the workspace...`,
       _config
     );
-    await chunkROM64JTJ_cjs.prepareHook(_config);
-    chunkPTYTYIPG_cjs.writeSuccess("\u2714 Prepare hook completed successfully!\n", _config);
+    await chunk4EOHM2UV_cjs.prepareHook(_config);
+    chunk4ILBJTRR_cjs.writeSuccess("\u2714 Prepare hook completed successfully!\n", _config);
   } catch (error) {
-    chunkPTYTYIPG_cjs.writeFatal(
+    chunk4ILBJTRR_cjs.writeFatal(
       `A fatal error occurred while running the prepare hook: 
 
 ${error.message}`,
@@ -4173,18 +5387,18 @@ ${error.message}`,
 
 // bin/git.ts
 void (async () => {
-  const config5 = await chunkPTYTYIPG_cjs.getConfig();
+  const config5 = await chunk4ILBJTRR_cjs.getConfig();
   try {
-    chunkPTYTYIPG_cjs.handleProcess(config5);
+    chunk4ILBJTRR_cjs.handleProcess(config5);
     const program = createProgram(config5);
     await program.parseAsync(process.argv);
-    chunkPTYTYIPG_cjs.writeSuccess(
+    chunk4ILBJTRR_cjs.writeSuccess(
       `\u2714 Git ${process.argv && process.argv.length >= 3 && process.argv[2] ? process.argv[2] : "tool"} processing completed successfully!`,
       config5
     );
-    chunkPTYTYIPG_cjs.exitWithSuccess(config5);
+    chunk4ILBJTRR_cjs.exitWithSuccess(config5);
   } catch (error) {
-    chunkPTYTYIPG_cjs.exitWithError(config5);
+    chunk4ILBJTRR_cjs.exitWithError(config5);
     process.exit(1);
   }
 })();