@williamthorsen/release-kit 2.3.2 → 4.0.0

package/dist/esm/init/templates.d.ts

@@ -1,3 +1,4 @@
 import type { RepoType } from './detectRepoType.ts';
 export declare function releaseConfigScript(repoType: RepoType): string;
+export declare function publishWorkflow(repoType: RepoType): string;
 export declare function releaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -35,6 +35,27 @@ const config: ReleaseKitConfig = {
 export default config;
 `;
 }
+function publishWorkflow(repoType) {
+  const tagPattern = repoType === "monorepo" ? "'*-v[0-9]*'" : "'v[0-9]*'";
+  return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+name: Publish
+
+on:
+  push:
+    tags:
+      - ${tagPattern}
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/publish.reusable.yaml@publish-workflow-v1
+    with:
+      provenance: false # Set to true for public repos to generate npm provenance attestations
+`;
+}
 function releaseWorkflow(repoType) {
   if (repoType === "monorepo") {
     return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
@@ -68,7 +89,7 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/node-monorepo-tools/.github/workflows/release-workflow.yaml@release-workflow-v1
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/release.reusable.yaml@release-workflow-v1
     with:
       only: \${{ inputs.only }}
       bump: \${{ inputs.bump }}
@@ -102,13 +123,14 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/node-monorepo-tools/.github/workflows/release-workflow.yaml@release-workflow-v1
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/release.reusable.yaml@release-workflow-v1
     with:
       bump: \${{ inputs.bump }}
       force: \${{ inputs.force }}
 `;
 }
 export {
+  publishWorkflow,
   releaseConfigScript,
   releaseWorkflow
 };

package/dist/esm/loadConfig.js

@@ -47,9 +47,9 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
   if (cliffConfigPath !== void 0) {
     result.cliffConfigPath = cliffConfigPath;
   }
-  const workspaceAliases = userConfig?.workspaceAliases;
-  if (workspaceAliases !== void 0) {
-    result.workspaceAliases = workspaceAliases;
+  const scopeAliases = userConfig?.scopeAliases;
+  if (scopeAliases !== void 0) {
+    result.scopeAliases = scopeAliases;
   }
   return result;
 }
@@ -71,9 +71,9 @@ function mergeSinglePackageConfig(userConfig) {
   if (cliffConfigPath !== void 0) {
     result.cliffConfigPath = cliffConfigPath;
   }
-  const workspaceAliases = userConfig?.workspaceAliases;
-  if (workspaceAliases !== void 0) {
-    result.workspaceAliases = workspaceAliases;
+  const scopeAliases = userConfig?.scopeAliases;
+  if (scopeAliases !== void 0) {
+    result.scopeAliases = scopeAliases;
   }
   return result;
 }

package/dist/esm/parseCommitMessage.d.ts

@@ -1,3 +1,3 @@
 import type { ParsedCommit, WorkTypeConfig } from './types.ts';
 export declare const COMMIT_PREPROCESSOR_PATTERNS: readonly RegExp[];
-export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, workspaceAliases?: Record<string, string>): ParsedCommit | undefined;
+export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, scopeAliases?: Record<string, string>): ParsedCommit | undefined;

package/dist/esm/parseCommitMessage.js

@@ -1,14 +1,15 @@
 const COMMIT_PREPROCESSOR_PATTERNS = [/^#\d+\s+/, /^[A-Z]+-\d+\s+/];
-function parseCommitMessage(message, hash, workTypes, workspaceAliases) {
+function parseCommitMessage(message, hash, workTypes, scopeAliases) {
   const stripped = stripTicketPrefix(message);
-  const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(!)?:\s*(.*)$/);
+  const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);
   if (!match) {
     return void 0;
   }
-  const workspace = match[1];
+  const pipeScope = match[1];
   const rawType = match[2];
-  const breakingMarker = match[3];
-  const description = match[4];
+  const parenthesizedScope = match[3];
+  const breakingMarker = match[4];
+  const description = match[5];
   if (rawType === void 0 || description === void 0) {
     return void 0;
   }
@@ -17,14 +18,15 @@ function parseCommitMessage(message, hash, workTypes, workspaceAliases) {
     return void 0;
   }
   const breaking = breakingMarker === "!" || message.includes("BREAKING CHANGE:");
-  const resolvedWorkspace = workspace !== void 0 && workspaceAliases !== void 0 ? workspaceAliases[workspace] ?? workspace : workspace;
+  const rawScope = pipeScope ?? parenthesizedScope;
+  const resolvedScope = rawScope !== void 0 && scopeAliases !== void 0 ? scopeAliases[rawScope] ?? rawScope : rawScope;
   return {
     message,
     hash,
     type: resolvedType,
     description,
     breaking,
-    ...resolvedWorkspace !== void 0 && { workspace: resolvedWorkspace }
+    ...resolvedScope !== void 0 && { scope: resolvedScope }
   };
 }
 function resolveType(rawType, workTypes) {

package/dist/esm/prepareCommand.d.ts

@@ -1,6 +1,7 @@
 import type { WriteResult } from '@williamthorsen/node-monorepo-core';
 import type { ReleaseType } from './types.ts';
 export declare const RELEASE_TAGS_FILE = "tmp/.release-tags";
+export declare const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 export declare function parseArgs(argv: string[]): {
     dryRun: boolean;
     force: boolean;

package/dist/esm/prepareCommand.js

@@ -1,4 +1,5 @@
 import { 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 +8,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);
@@ -148,8 +150,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

@@ -4,7 +4,7 @@ import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { publish } from "./publish.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
 async function publishCommand(argv) {
-  const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--no-git-checks"]);
+  const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--no-git-checks", "--provenance"]);
   const unknownFlags = argv.filter((f) => !f.startsWith("--only=") && !knownFlags.has(f));
   if (unknownFlags.length > 0) {
     console.error(`Error: Unknown option: ${unknownFlags[0]}`);
@@ -12,6 +12,7 @@ async function publishCommand(argv) {
   }
   const dryRun = argv.includes("--dry-run");
   const noGitChecks = argv.includes("--no-git-checks");
+  const provenance = argv.includes("--provenance");
   const onlyArg = argv.find((f) => f.startsWith("--only="));
   const only = onlyArg?.slice("--only=".length).split(",");
   let discoveredPaths;
@@ -43,7 +44,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