@williamthorsen/release-kit 2.3.2 → 4.4.0

package/dist/esm/prepareCommand.js

@@ -1,4 +1,9 @@
-import { writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
+import {
+  parseArgs as coreParseArgs,
+  translateParseError,
+  writeFileWithCheck
+} from "@williamthorsen/node-monorepo-core";
+import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
 import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig } from "./loadConfig.js";
@@ -7,6 +12,7 @@ import { releasePrepareMono } from "./releasePrepareMono.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { validateConfig } from "./validateConfig.js";
 const RELEASE_TAGS_FILE = "tmp/.release-tags";
+const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 const VALID_BUMP_TYPES = ["major", "minor", "patch"];
 function isReleaseType(value) {
   return VALID_BUMP_TYPES.includes(value);
@@ -23,43 +29,40 @@ Options:
   --help                Show this help message
 `);
 }
+const prepareFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" },
+  force: { long: "--force", type: "boolean" },
+  bump: { long: "--bump", type: "string" },
+  only: { long: "--only", type: "string" },
+  help: { long: "--help", type: "boolean", short: "-h" }
+};
 function parseArgs(argv) {
-  let dryRun = false;
-  let force = false;
+  let parsed;
+  try {
+    parsed = coreParseArgs(argv, prepareFlagSchema);
+  } catch (error) {
+    throw new Error(translateParseError(error));
+  }
+  const { flags } = parsed;
+  if (flags.help) {
+    showHelp();
+    process.exit(0);
+  }
   let bumpOverride;
-  let only;
-  for (const arg of argv) {
-    if (arg === "--dry-run") {
-      dryRun = true;
-    } else if (arg === "--force") {
-      force = true;
-    } else if (arg.startsWith("--bump=")) {
-      const value = arg.slice("--bump=".length);
-      if (!isReleaseType(value)) {
-        console.error(`Error: Invalid bump type "${value}". Must be one of: ${VALID_BUMP_TYPES.join(", ")}`);
-        process.exit(1);
-      }
-      bumpOverride = value;
-    } else if (arg.startsWith("--only=")) {
-      const value = arg.slice("--only=".length);
-      if (!value) {
-        console.error("Error: --only requires a comma-separated list of component names");
-        process.exit(1);
-      }
-      only = value.split(",");
-    } else if (arg === "--help" || arg === "-h") {
-      showHelp();
-      process.exit(0);
-    } else {
-      console.error(`Error: Unknown argument: ${arg}`);
-      process.exit(1);
+  if (flags.bump !== void 0) {
+    if (!isReleaseType(flags.bump)) {
+      throw new Error(`Invalid bump type "${flags.bump}". Must be one of: ${VALID_BUMP_TYPES.join(", ")}`);
     }
+    bumpOverride = flags.bump;
   }
-  if (force && bumpOverride === void 0) {
-    console.error("Error: --force requires --bump to specify the version bump type");
-    process.exit(1);
+  let only;
+  if (flags.only !== void 0) {
+    only = flags.only.split(",");
+  }
+  if (flags.force && bumpOverride === void 0) {
+    throw new Error("--force requires --bump to specify the version bump type");
   }
-  return { dryRun, force, bumpOverride, only };
+  return { dryRun: flags.dryRun, force: flags.force, bumpOverride, only };
 }
 function writeReleaseTags(tags, dryRun) {
   if (tags.length === 0) {
@@ -68,7 +71,16 @@ function writeReleaseTags(tags, dryRun) {
   return writeFileWithCheck(RELEASE_TAGS_FILE, tags.join("\n"), { dryRun, overwrite: true });
 }
 async function prepareCommand(argv) {
-  const { dryRun, force, bumpOverride, only } = parseArgs(argv);
+  let dryRun;
+  let force;
+  let bumpOverride;
+  let only;
+  try {
+    ({ dryRun, force, bumpOverride, only } = parseArgs(argv));
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
   const options = {
     dryRun,
     force,
@@ -148,8 +160,26 @@ function runAndReport(execute, dryRun) {
    Release tags file: ${RELEASE_TAGS_FILE}`));
     }
   }
+  const summary = buildReleaseSummary(result);
+  if (summary.length > 0) {
+    const summaryResult = writeFileWithCheck(RELEASE_SUMMARY_FILE, summary, { dryRun, overwrite: true });
+    if (summaryResult.outcome === "failed") {
+      console.error(`Error writing release summary: ${summaryResult.error ?? "unknown error"}`);
+      process.exit(1);
+    }
+    if (dryRun) {
+      console.info(dim(`  [dry-run] Would write ${RELEASE_SUMMARY_FILE}`));
+    } else {
+      console.info(dim(`  Wrote ${RELEASE_SUMMARY_FILE}`));
+    }
+  }
+  if (writeResult && !dryRun) {
+    console.error(`
+Run 'release-kit commit' to create the release commit.`);
+  }
 }
 export {
+  RELEASE_SUMMARY_FILE,
   RELEASE_TAGS_FILE,
   parseArgs,
   prepareCommand,

package/dist/esm/propagateBumps.d.ts

@@ -0,0 +1,8 @@
+import type { DependencyGraph } from './buildDependencyGraph.ts';
+import type { PropagationSource, ReleaseType } from './types.ts';
+export interface ReleaseEntry {
+    releaseType: ReleaseType;
+    propagatedFrom?: PropagationSource[];
+}
+export type CurrentVersions = Map<string, string>;
+export declare function propagateBumps(directBumps: Map<string, ReleaseEntry>, graph: DependencyGraph, currentVersions: CurrentVersions): Map<string, ReleaseEntry>;

package/dist/esm/propagateBumps.js

@@ -0,0 +1,54 @@
+import { bumpVersion } from "./bumpVersion.js";
+function propagateBumps(directBumps, graph, currentVersions) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [dir, entry] of directBumps) {
+    result.set(dir, { ...entry });
+  }
+  const queue = [...directBumps.keys()];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const dir = queue.shift();
+    if (dir === void 0) {
+      break;
+    }
+    if (visited.has(dir)) {
+      continue;
+    }
+    visited.add(dir);
+    const packageName = graph.dirToPackageName.get(dir);
+    if (packageName === void 0) {
+      continue;
+    }
+    const currentVersion = currentVersions.get(dir);
+    const entry = result.get(dir);
+    if (currentVersion === void 0 || entry === void 0) {
+      continue;
+    }
+    const newVersion = bumpVersion(currentVersion, entry.releaseType);
+    const dependents = graph.dependentsOf.get(packageName);
+    if (dependents === void 0) {
+      continue;
+    }
+    for (const dependent of dependents) {
+      const dependentDir = dependent.dir;
+      const existing = result.get(dependentDir);
+      const propagationInfo = { packageName, newVersion };
+      if (existing === void 0) {
+        result.set(dependentDir, {
+          releaseType: "patch",
+          propagatedFrom: [propagationInfo]
+        });
+      } else {
+        const existingPropagated = existing.propagatedFrom ?? [];
+        existing.propagatedFrom = [...existingPropagated, propagationInfo];
+      }
+      if (!visited.has(dependentDir)) {
+        queue.push(dependentDir);
+      }
+    }
+  }
+  return result;
+}
+export {
+  propagateBumps
+};

package/dist/esm/publish.d.ts

@@ -3,5 +3,6 @@ import type { ResolvedTag } from './resolveReleaseTags.ts';
 export interface PublishOptions {
     dryRun: boolean;
     noGitChecks: boolean;
+    provenance: boolean;
 }
 export declare function publish(resolvedTags: ResolvedTag[], packageManager: PackageManager, options: PublishOptions): void;

package/dist/esm/publish.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 function publish(resolvedTags, packageManager, options) {
-  const { dryRun, noGitChecks } = options;
+  const { dryRun, noGitChecks, provenance } = options;
   if (resolvedTags.length === 0) {
     return;
   }
@@ -9,9 +9,9 @@ function publish(resolvedTags, packageManager, options) {
     console.info(`  ${tag} (${workspacePath})`);
   }
   const published = [];
+  const executable = resolveExecutable(packageManager);
+  const args = buildPublishArgs(packageManager, { dryRun, noGitChecks, provenance });
   for (const { tag, workspacePath } of resolvedTags) {
-    const executable = resolveExecutable(packageManager);
-    const args = buildPublishArgs(packageManager, { dryRun, noGitChecks });
     try {
       console.info(`
 ${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${workspacePath})`);
@@ -42,6 +42,9 @@ function buildPublishArgs(packageManager, options) {
   if (options.noGitChecks && packageManager === "pnpm") {
     args.push("--no-git-checks");
   }
+  if (options.provenance && packageManager !== "yarn") {
+    args.push("--provenance");
+  }
   return args;
 }
 export {

package/dist/esm/publishCommand.js

@@ -1,19 +1,25 @@
 import { basename } from "node:path";
+import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { publish } from "./publish.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
+const publishFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" },
+  noGitChecks: { long: "--no-git-checks", type: "boolean" },
+  provenance: { long: "--provenance", type: "boolean" },
+  only: { long: "--only", type: "string" }
+};
 async function publishCommand(argv) {
-  const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--no-git-checks"]);
-  const unknownFlags = argv.filter((f) => !f.startsWith("--only=") && !knownFlags.has(f));
-  if (unknownFlags.length > 0) {
-    console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+  let parsed;
+  try {
+    parsed = parseArgs(argv, publishFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
     process.exit(1);
   }
-  const dryRun = argv.includes("--dry-run");
-  const noGitChecks = argv.includes("--no-git-checks");
-  const onlyArg = argv.find((f) => f.startsWith("--only="));
-  const only = onlyArg?.slice("--only=".length).split(",");
+  const { dryRun, noGitChecks, provenance } = parsed.flags;
+  const only = parsed.flags.only?.split(",");
   let discoveredPaths;
   try {
     discoveredPaths = await discoverWorkspaces();
@@ -43,7 +49,7 @@ async function publishCommand(argv) {
   }
   const packageManager = detectPackageManager();
   try {
-    publish(resolvedTags, packageManager, { dryRun, noGitChecks });
+    publish(resolvedTags, packageManager, { dryRun, noGitChecks, provenance });
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);

package/dist/esm/releasePrepare.js

@@ -14,7 +14,7 @@ function releasePrepare(config, options) {
   let parsedCommitCount;
   let unparseableCommits;
   if (bumpOverride === void 0) {
-    const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.workspaceAliases);
+    const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases);
     parsedCommitCount = determination.parsedCommitCount;
     unparseableCommits = determination.unparseableCommits;
     releaseType = determination.releaseType;
@@ -73,6 +73,7 @@ function releasePrepare(config, options) {
         tag: newTag,
         bumpedFiles: bump.files,
         changelogFiles,
+        commits,
         unparseableCommits
       }
     ],

package/dist/esm/releasePrepareMono.js

@@ -1,29 +1,84 @@
 import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
-import { generateChangelog } from "./generateChangelogs.js";
+import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
+import { propagateBumps } from "./propagateBumps.js";
+import { writeSyntheticChangelog } from "./writeSyntheticChangelog.js";
 function releasePrepareMono(config, options) {
-  const { dryRun, force, bumpOverride } = options;
+  const { dryRun } = options;
+  const { directBumps, directResults, skippedResults, currentVersions } = determineDirectBumps(config, options);
+  const previousTags = /* @__PURE__ */ new Map();
+  for (const result of directResults.values()) {
+    previousTags.set(result.component.dir, result.tag);
+  }
+  for (const skipped of skippedResults) {
+    previousTags.set(skipped.component.dir, skipped.tag);
+  }
+  const graph = buildDependencyGraph(config.components);
+  const fullReleaseSet = propagateBumps(directBumps, graph, currentVersions);
+  const { sorted: sortedDirs, cyclicDirs } = topologicalSort(fullReleaseSet, graph);
+  const warnings = [];
+  if (cyclicDirs.length > 0) {
+    warnings.push(
+      `Circular workspace dependencies detected among: ${cyclicDirs.join(", ")}. Propagation metadata may be incomplete for these components.`
+    );
+  }
+  const components = collectSkippedComponents(skippedResults, fullReleaseSet);
+  const { tags, modifiedFiles } = executeReleaseSet(
+    sortedDirs,
+    fullReleaseSet,
+    config,
+    directResults,
+    previousTags,
+    dryRun,
+    components
+  );
+  const configOrder = new Map(config.components.map((c, i) => [c.dir, i]));
+  components.sort((a, b) => {
+    const orderA = configOrder.get(a.name ?? "") ?? 0;
+    const orderB = configOrder.get(b.name ?? "") ?? 0;
+    return orderA - orderB;
+  });
+  const formatCommand = runFormatCommand(config, tags, modifiedFiles, dryRun);
+  return {
+    components,
+    tags,
+    formatCommand,
+    dryRun,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function determineDirectBumps(config, options) {
+  const { force, bumpOverride } = options;
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-  const tags = [];
-  const modifiedFiles = [];
-  const components = [];
+  const directBumps = /* @__PURE__ */ new Map();
+  const directResults = /* @__PURE__ */ new Map();
+  const skippedResults = [];
+  const currentVersions = /* @__PURE__ */ new Map();
   for (const component of config.components) {
     const name = component.dir;
     const { tag, commits } = getCommitsSinceTarget(component.tagPrefix, component.paths);
     const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+    const primaryPackageFile = component.packageFiles[0];
+    if (primaryPackageFile !== void 0) {
+      const currentVersion = readCurrentVersion(primaryPackageFile);
+      if (currentVersion !== void 0) {
+        currentVersions.set(component.dir, currentVersion);
+      }
+    }
     if (commits.length === 0 && !force) {
-      components.push({
-        name,
-        status: "skipped",
-        previousTag: tag,
+      skippedResults.push({
+        component,
+        tag,
         commitCount: 0,
-        bumpedFiles: [],
-        changelogFiles: [],
+        parsedCommitCount: void 0,
+        unparseableCommits: void 0,
         skipReason: `No changes for ${name} ${since}. Skipping.`
       });
       continue;
@@ -32,7 +87,7 @@ function releasePrepareMono(config, options) {
     let parsedCommitCount;
     let unparseableCommits;
     if (bumpOverride === void 0) {
-      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.workspaceAliases);
+      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases);
       parsedCommitCount = determination.parsedCommitCount;
       unparseableCommits = determination.unparseableCommits;
       releaseType = determination.releaseType;
@@ -40,67 +95,201 @@ function releasePrepareMono(config, options) {
       releaseType = bumpOverride;
     }
     if (releaseType === void 0) {
-      components.push({
-        name,
-        status: "skipped",
-        previousTag: tag,
+      skippedResults.push({
+        component,
+        tag,
         commitCount: commits.length,
         parsedCommitCount,
         unparseableCommits,
-        bumpedFiles: [],
-        changelogFiles: [],
         skipReason: `No release-worthy changes for ${name} ${since}. Skipping.`
       });
       continue;
     }
-    const bump = bumpAllVersions(component.packageFiles, releaseType, dryRun);
+    directBumps.set(component.dir, { releaseType });
+    directResults.set(component.dir, {
+      component,
+      tag,
+      commits,
+      releaseType,
+      parsedCommitCount,
+      unparseableCommits
+    });
+  }
+  return { directBumps, directResults, skippedResults, currentVersions };
+}
+function collectSkippedComponents(skippedResults, fullReleaseSet) {
+  const components = [];
+  for (const skipped of skippedResults) {
+    if (fullReleaseSet.has(skipped.component.dir)) {
+      continue;
+    }
+    components.push({
+      name: skipped.component.dir,
+      status: "skipped",
+      previousTag: skipped.tag,
+      commitCount: skipped.commitCount,
+      parsedCommitCount: skipped.parsedCommitCount,
+      unparseableCommits: skipped.unparseableCommits,
+      bumpedFiles: [],
+      changelogFiles: [],
+      skipReason: skipped.skipReason
+    });
+  }
+  return components;
+}
+function executeReleaseSet(sortedDirs, fullReleaseSet, config, directResults, previousTags, dryRun, components) {
+  const tags = [];
+  const modifiedFiles = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  for (const dir of sortedDirs) {
+    const releaseEntry = fullReleaseSet.get(dir);
+    if (releaseEntry === void 0) {
+      continue;
+    }
+    const component = findComponent(config.components, dir);
+    if (component === void 0) {
+      continue;
+    }
+    const bump = bumpAllVersions(component.packageFiles, releaseEntry.releaseType, dryRun);
     const newTag = `${component.tagPrefix}${bump.newVersion}`;
     tags.push(newTag);
     modifiedFiles.push(...component.packageFiles, ...component.changelogPaths.map((p) => `${p}/CHANGELOG.md`));
     const changelogFiles = [];
-    for (const changelogPath of component.changelogPaths) {
-      changelogFiles.push(
-        ...generateChangelog(config, changelogPath, newTag, dryRun, { includePaths: component.paths })
-      );
+    const directResult = directResults.get(dir);
+    const isPropagationOnly = directResult === void 0;
+    if (isPropagationOnly && releaseEntry.propagatedFrom !== void 0) {
+      for (const changelogPath of component.changelogPaths) {
+        changelogFiles.push(
+          writeSyntheticChangelog({
+            changelogPath,
+            newVersion: bump.newVersion,
+            date: today,
+            propagatedFrom: releaseEntry.propagatedFrom,
+            dryRun
+          })
+        );
+      }
+    } else {
+      for (const changelogPath of component.changelogPaths) {
+        changelogFiles.push(
+          ...generateChangelog(config, changelogPath, newTag, dryRun, {
+            tagPattern: buildTagPattern(component.tagPrefix),
+            includePaths: component.paths
+          })
+        );
+      }
     }
     components.push({
-      name,
+      name: dir,
       status: "released",
-      previousTag: tag,
-      commitCount: commits.length,
-      parsedCommitCount,
-      releaseType,
+      previousTag: directResult?.tag ?? previousTags.get(dir),
+      commitCount: directResult?.commits.length ?? 0,
+      parsedCommitCount: directResult?.parsedCommitCount,
+      releaseType: releaseEntry.releaseType,
       currentVersion: bump.currentVersion,
       newVersion: bump.newVersion,
       tag: newTag,
       bumpedFiles: bump.files,
       changelogFiles,
-      unparseableCommits
+      commits: directResult?.commits,
+      unparseableCommits: directResult?.unparseableCommits,
+      propagatedFrom: releaseEntry.propagatedFrom
     });
   }
+  return { tags, modifiedFiles };
+}
+function runFormatCommand(config, tags, modifiedFiles, dryRun) {
   const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
-  let formatCommand;
-  if (tags.length > 0 && formatCommandStr !== void 0) {
-    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
-    if (dryRun) {
-      formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
-    } else {
-      try {
-        execSync(fullCommand, { stdio: "inherit" });
-      } catch (error) {
-        throw new Error(
-          `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
-        );
+  if (tags.length === 0 || formatCommandStr === void 0) {
+    return void 0;
+  }
+  const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
+  if (dryRun) {
+    return { command: fullCommand, executed: false, files: modifiedFiles };
+  }
+  try {
+    execSync(fullCommand, { stdio: "inherit" });
+  } catch (error) {
+    throw new Error(
+      `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return { command: fullCommand, executed: true, files: modifiedFiles };
+}
+function findComponent(components, dir) {
+  return components.find((c) => c.dir === dir);
+}
+function hasVersionField(value) {
+  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
+}
+function readCurrentVersion(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (hasVersionField(parsed)) {
+      return parsed.version;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function topologicalSort(releaseSet, graph) {
+  const releaseDirs = new Set(releaseSet.keys());
+  if (releaseDirs.size === 0) {
+    return { sorted: [], cyclicDirs: [] };
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const forwardEdges = /* @__PURE__ */ new Map();
+  for (const dir of releaseDirs) {
+    inDegree.set(dir, 0);
+    forwardEdges.set(dir, []);
+  }
+  for (const [packageName, dependents] of graph.dependentsOf) {
+    const depDir = graph.packageNameToDir.get(packageName);
+    if (depDir === void 0 || !releaseDirs.has(depDir)) {
+      continue;
+    }
+    for (const dependent of dependents) {
+      if (!releaseDirs.has(dependent.dir)) {
+        continue;
       }
-      formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
+      const edges = forwardEdges.get(depDir);
+      if (edges !== void 0) {
+        edges.push(dependent.dir);
+      }
+      inDegree.set(dependent.dir, (inDegree.get(dependent.dir) ?? 0) + 1);
     }
   }
-  return {
-    components,
-    tags,
-    formatCommand,
-    dryRun
-  };
+  const queue = [];
+  for (const [dir, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(dir);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const dir = queue.shift();
+    if (dir === void 0) {
+      break;
+    }
+    sorted.push(dir);
+    for (const dependent of forwardEdges.get(dir) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) {
+        queue.push(dependent);
+      }
+    }
+  }
+  const sortedSet = new Set(sorted);
+  const cyclicDirs = [];
+  for (const dir of releaseDirs) {
+    if (!sortedSet.has(dir)) {
+      sorted.push(dir);
+      cyclicDirs.push(dir);
+    }
+  }
+  return { sorted, cyclicDirs };
 }
 export {
   releasePrepareMono