verelease 0.1.2-alpha.2 → 0.1.2-alpha.4

package/dist/bin.js

@@ -1,12 +1,250 @@
 #!/usr/bin/env node
 
+// src/bin.ts
+import { defineCommand, runMain } from "citty";
+import { readFile as readFile15 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { join as join20, dirname as dirname3 } from "path";
+
 // src/cli.ts
-import { resolve as resolve2, join as join13 } from "path";
-import { writeFile as writeFile5, mkdir as mkdir6, readFile as readFile7, unlink, rm as rm4 } from "fs/promises";
-import { mkdtemp as mkdtemp5 } from "fs/promises";
-import { tmpdir as tmpdir5 } from "os";
+import { resolve as resolve2, join as join19 } from "path";
+import { writeFile as writeFile6, mkdir as mkdir6, readFile as readFile14, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp7 } from "fs/promises";
+import { tmpdir as tmpdir7 } from "os";
 import { existsSync } from "fs";
-import { createInterface } from "readline/promises";
+import * as prompts3 from "@clack/prompts";
+import colors3 from "picocolors";
+import * as Effect4 from "effect/Effect";
+import * as Exit2 from "effect/Exit";
+
+// ../core/dist/errors.js
+import * as Data from "effect/Data";
+var NpmAuthError = class extends Data.TaggedError("NpmAuthError") {
+};
+var BaselineFetchError = class extends Data.TaggedError("BaselineFetchError") {
+};
+var TestExecutionError = class extends Data.TaggedError("TestExecutionError") {
+};
+var ManifestMutationError = class extends Data.TaggedError("ManifestMutationError") {
+};
+var LockfileSyncError = class extends Data.TaggedError("LockfileSyncError") {
+};
+var PublishError = class extends Data.TaggedError("PublishError") {
+};
+var RegistryCollisionError = class extends Data.TaggedError("RegistryCollisionError") {
+};
+var CargoAuthError = class extends Data.TaggedError("CargoAuthError") {
+};
+
+// ../core/dist/transaction.js
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { readFile, writeFile, unlink, stat } from "fs/promises";
+import { join } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+async function fileExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+function executeReleaseTransaction(options, use) {
+  const { plan, cwd, lockfileAdapter, onRollback, onStep } = options;
+  const acquire = Effect.tryPromise({
+    try: async () => {
+      onStep?.("Creating manifest backups...");
+      const filesToTouch = /* @__PURE__ */ new Set();
+      for (const pkgPlan of plan.packages) {
+        if (pkgPlan.bump !== "none") {
+          const pkgJson = join(pkgPlan.directory, "package.json");
+          const jsrJson = join(pkgPlan.directory, "jsr.json");
+          const denoJson = join(pkgPlan.directory, "deno.json");
+          const cargoToml = join(pkgPlan.directory, "Cargo.toml");
+          if (await fileExists(pkgJson))
+            filesToTouch.add(pkgJson);
+          if (await fileExists(jsrJson))
+            filesToTouch.add(jsrJson);
+          if (await fileExists(denoJson))
+            filesToTouch.add(denoJson);
+          if (await fileExists(cargoToml))
+            filesToTouch.add(cargoToml);
+        }
+        for (const update of pkgPlan.dependentUpdates) {
+          const depPkgPlan = plan.packages.find((p) => p.name === update.dependentName);
+          if (depPkgPlan) {
+            const depPkgJson = join(depPkgPlan.directory, "package.json");
+            const depCargoToml = join(depPkgPlan.directory, "Cargo.toml");
+            if (await fileExists(depPkgJson))
+              filesToTouch.add(depPkgJson);
+            if (await fileExists(depCargoToml))
+              filesToTouch.add(depCargoToml);
+          }
+        }
+      }
+      const backups = [];
+      for (const filePath of filesToTouch) {
+        const originalContent = await readFile(filePath, "utf8");
+        backups.push({ filePath, originalContent });
+      }
+      onStep?.("Applying version bumps to manifests...");
+      const versionMap = /* @__PURE__ */ new Map();
+      for (const pkgPlan of plan.packages) {
+        if (pkgPlan.bump !== "none") {
+          versionMap.set(pkgPlan.name, pkgPlan.proposedVersion);
+        }
+      }
+      const depUpdateMap = /* @__PURE__ */ new Map();
+      for (const pkgPlan of plan.packages) {
+        for (const depUp of pkgPlan.dependentUpdates) {
+          if (!depUpdateMap.has(depUp.dependentName)) {
+            depUpdateMap.set(depUp.dependentName, []);
+          }
+          depUpdateMap.get(depUp.dependentName).push({
+            dependencyName: depUp.dependencyName,
+            newRange: depUp.newRange,
+            type: depUp.dependencyType
+          });
+        }
+      }
+      const modifiedManifests = [];
+      for (const pkgPlan of plan.packages) {
+        const pkgJsonPath = join(pkgPlan.directory, "package.json");
+        if (filesToTouch.has(pkgJsonPath)) {
+          const content = await readFile(pkgJsonPath, "utf8");
+          const parsed = JSON.parse(content);
+          if (versionMap.has(pkgPlan.name)) {
+            parsed.version = versionMap.get(pkgPlan.name);
+          }
+          const depUpdates = depUpdateMap.get(pkgPlan.name);
+          if (depUpdates) {
+            for (const up of depUpdates) {
+              const sec = parsed[up.type];
+              if (sec && sec[up.dependencyName]) {
+                sec[up.dependencyName] = up.newRange;
+              }
+            }
+          }
+          await writeFile(pkgJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+          modifiedManifests.push(pkgJsonPath);
+        }
+        const jsrJsonPath = join(pkgPlan.directory, "jsr.json");
+        if (filesToTouch.has(jsrJsonPath)) {
+          const content = await readFile(jsrJsonPath, "utf8");
+          const parsed = JSON.parse(content);
+          if (versionMap.has(pkgPlan.name)) {
+            parsed.version = versionMap.get(pkgPlan.name);
+          }
+          await writeFile(jsrJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+          modifiedManifests.push(jsrJsonPath);
+        }
+        const denoJsonPath = join(pkgPlan.directory, "deno.json");
+        if (filesToTouch.has(denoJsonPath)) {
+          const content = await readFile(denoJsonPath, "utf8");
+          const parsed = JSON.parse(content);
+          if (versionMap.has(pkgPlan.name)) {
+            parsed.version = versionMap.get(pkgPlan.name);
+          }
+          await writeFile(denoJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+          modifiedManifests.push(denoJsonPath);
+        }
+        const cargoTomlPath = join(pkgPlan.directory, "Cargo.toml");
+        if (filesToTouch.has(cargoTomlPath)) {
+          const content = await readFile(cargoTomlPath, "utf8");
+          const parsed = parseToml(content);
+          if (versionMap.has(pkgPlan.name) && parsed.package && typeof parsed.package === "object") {
+            parsed.package.version = versionMap.get(pkgPlan.name);
+          }
+          const depUpdates = depUpdateMap.get(pkgPlan.name);
+          if (depUpdates) {
+            for (const up of depUpdates) {
+              for (const section of ["dependencies", "dev-dependencies", "build-dependencies"]) {
+                const dependencies = parsed[section];
+                if (!dependencies || typeof dependencies !== "object" || !(up.dependencyName in dependencies)) {
+                  continue;
+                }
+                const dependency = dependencies[up.dependencyName];
+                if (typeof dependency === "string") {
+                  dependencies[up.dependencyName] = up.newRange;
+                } else if (dependency && typeof dependency === "object") {
+                  dependency.version = up.newRange;
+                }
+              }
+            }
+          }
+          await writeFile(cargoTomlPath, stringifyToml(parsed), "utf8");
+          modifiedManifests.push(cargoTomlPath);
+        }
+      }
+      onStep?.(`Regenerating lockfile with ${lockfileAdapter.packageManager}...`);
+      const lockRes = await lockfileAdapter.regenerateLockfile(cwd);
+      if (!lockRes.success) {
+        for (const b of backups) {
+          await writeFile(b.filePath, b.originalContent, "utf8");
+        }
+        throw new Error(`Lockfile generation failed: ${lockRes.output}`);
+      }
+      const changelogBackups = /* @__PURE__ */ new Map();
+      const generatedFiles = /* @__PURE__ */ new Set();
+      const scope = {
+        plan,
+        modifiedManifests,
+        changelogBackups,
+        generatedFiles,
+        backupChangelog(path, original) {
+          changelogBackups.set(path, original);
+        },
+        trackGeneratedFile(path) {
+          generatedFiles.add(path);
+        }
+      };
+      return { scope, backups };
+    },
+    catch: (err) => new ManifestMutationError({
+      message: err instanceof Error ? err.message : String(err)
+    })
+  });
+  const release = (resource, exit) => Effect.promise(async () => {
+    if (Exit.isFailure(exit)) {
+      onRollback?.("Rolling back manifests to previous versions...");
+      for (const b of resource.backups) {
+        try {
+          await writeFile(b.filePath, b.originalContent, "utf8");
+        } catch {
+        }
+      }
+      onRollback?.("Restored manifests.");
+      onRollback?.("Restoring changelog files...");
+      for (const [chPath, original] of resource.scope.changelogBackups) {
+        try {
+          if (original === null) {
+            await unlink(chPath);
+          } else {
+            await writeFile(chPath, original, "utf8");
+          }
+        } catch {
+        }
+      }
+      onRollback?.("Restored changelog files.");
+      onRollback?.("Removing generated migration guides...");
+      for (const genPath of resource.scope.generatedFiles) {
+        try {
+          await unlink(genPath);
+        } catch {
+        }
+      }
+      onRollback?.("Removed generated migration guides.");
+      onRollback?.("Synchronizing workspace lockfile...");
+      try {
+        await lockfileAdapter.regenerateLockfile(cwd);
+        onRollback?.("Synchronized lockfile.");
+      } catch {
+      }
+    }
+  });
+  return Effect.acquireUseRelease(acquire, ({ scope }) => use(scope), release);
+}
 
 // ../workspace/dist/graph.js
 var PackageGraphImpl = class {
@@ -160,12 +398,13 @@ var PackageGraphImpl = class {
 };
 
 // ../workspace/dist/resolver.js
-import { readFile, stat, readdir } from "fs/promises";
-import { join, relative, resolve } from "path";
+import { readFile as readFile2, stat as stat2, readdir } from "fs/promises";
+import { join as join2, relative, resolve } from "path";
 import { parse as parseYaml } from "yaml";
-async function fileExists(path) {
+import { parse as parseToml2 } from "smol-toml";
+async function fileExists2(path) {
   try {
-    const s = await stat(path);
+    const s = await stat2(path);
     return s.isFile();
   } catch {
     return false;
@@ -173,113 +412,343 @@ async function fileExists(path) {
 }
 async function dirExists(path) {
   try {
-    const s = await stat(path);
+    const s = await stat2(path);
     return s.isDirectory();
   } catch {
     return false;
   }
 }
+function extractCargoDeps(depSection) {
+  const result = {};
+  if (!depSection || typeof depSection !== "object")
+    return result;
+  for (const [key, value] of Object.entries(depSection)) {
+    if (typeof value === "string") {
+      result[key] = value;
+    } else if (value && typeof value === "object") {
+      const depObj = value;
+      if (typeof depObj.version === "string") {
+        result[key] = depObj.version;
+      } else if (depObj.path) {
+        result[key] = "*";
+      } else if (depObj.workspace === true) {
+        result[key] = "workspace:*";
+      }
+    }
+  }
+  return result;
+}
 var DefaultWorkspaceResolver = class {
   name = "default-workspace-resolver";
   async supports(rootDir) {
-    const pnpmWorkspace = join(rootDir, "pnpm-workspace.yaml");
-    const packageJson = join(rootDir, "package.json");
-    return await fileExists(pnpmWorkspace) || await fileExists(packageJson);
+    const pnpmWorkspace = join2(rootDir, "pnpm-workspace.yaml");
+    const packageJson = join2(rootDir, "package.json");
+    const cargoToml = join2(rootDir, "Cargo.toml");
+    return await fileExists2(pnpmWorkspace) || await fileExists2(packageJson) || await fileExists2(cargoToml);
   }
   async resolve(rootDir) {
     const absRootDir = resolve(rootDir);
-    const pnpmWorkspacePath = join(absRootDir, "pnpm-workspace.yaml");
-    const rootPkgJsonPath = join(absRootDir, "package.json");
-    let packageManager = "unknown";
-    let patterns = [];
-    if (await fileExists(pnpmWorkspacePath)) {
-      packageManager = "pnpm";
-      const content = await readFile(pnpmWorkspacePath, "utf8");
-      const parsed = parseYaml(content);
-      if (parsed && Array.isArray(parsed.packages)) {
-        patterns = parsed.packages;
-      }
-    } else if (await fileExists(rootPkgJsonPath)) {
-      const content = await readFile(rootPkgJsonPath, "utf8");
-      const parsed = JSON.parse(content);
-      if (Array.isArray(parsed.workspaces)) {
-        patterns = parsed.workspaces;
-        packageManager = "npm";
-      } else if (parsed.workspaces && Array.isArray(parsed.workspaces.packages)) {
-        patterns = parsed.workspaces.packages;
-        packageManager = "yarn";
-      } else {
-        const pkg = {
-          name: parsed.name || "unnamed-package",
-          version: parsed.version || "0.0.0",
-          directory: absRootDir,
-          manifestPath: rootPkgJsonPath,
-          manifest: parsed,
-          isPrivate: !!parsed.private,
-          relativeDir: "."
-        };
-        const graph2 = new PackageGraphImpl([pkg]);
-        return {
-          rootDirectory: absRootDir,
-          packageManager: "npm",
-          packages: [pkg],
-          graph: graph2
-        };
+    const pnpmWorkspacePath = join2(absRootDir, "pnpm-workspace.yaml");
+    const rootPkgJsonPath = join2(absRootDir, "package.json");
+    const rootCargoTomlPath = join2(absRootDir, "Cargo.toml");
+    const allPackages = [];
+    const skipped = [];
+    const ecosystems = [];
+    let detectedPackageManager = "unknown";
+    const hasPnpmWorkspace = await fileExists2(pnpmWorkspacePath);
+    const hasRootPkgJson = await fileExists2(rootPkgJsonPath);
+    if (hasPnpmWorkspace || hasRootPkgJson) {
+      let jsPatterns = [];
+      let jsPackageManager = "unknown";
+      if (hasPnpmWorkspace) {
+        jsPackageManager = "pnpm";
+        try {
+          const content = await readFile2(pnpmWorkspacePath, "utf8");
+          const parsed = parseYaml(content);
+          if (parsed && Array.isArray(parsed.packages)) {
+            jsPatterns = parsed.packages;
+          }
+        } catch {
+        }
+      } else if (hasRootPkgJson) {
+        try {
+          const content = await readFile2(rootPkgJsonPath, "utf8");
+          const parsed = JSON.parse(content);
+          if (Array.isArray(parsed.workspaces)) {
+            jsPatterns = parsed.workspaces;
+            jsPackageManager = "npm";
+          } else if (parsed.workspaces && Array.isArray(parsed.workspaces.packages)) {
+            jsPatterns = parsed.workspaces.packages;
+            jsPackageManager = "yarn";
+          } else {
+            const pkg = {
+              name: parsed.name || "unnamed-package",
+              version: parsed.version || "0.0.0",
+              directory: absRootDir,
+              manifestPath: rootPkgJsonPath,
+              manifest: parsed,
+              isPrivate: !!parsed.private,
+              relativeDir: ".",
+              ecosystem: "npm"
+            };
+            allPackages.push(pkg);
+            ecosystems.push("npm");
+            detectedPackageManager = "npm";
+          }
+        } catch {
+        }
       }
-    }
-    if (patterns.length === 0) {
-      patterns = ["packages/*"];
-    }
-    const matchedDirs = /* @__PURE__ */ new Set();
-    for (const pattern of patterns) {
-      if (pattern.endsWith("/*")) {
-        const baseDir = join(absRootDir, pattern.slice(0, -2));
-        if (await dirExists(baseDir)) {
-          const entries = await readdir(baseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              matchedDirs.add(join(baseDir, entry.name));
-            }
+      if (jsPatterns.length > 0) {
+        detectedPackageManager = jsPackageManager;
+        ecosystems.push("npm");
+        const matchedDirs = /* @__PURE__ */ new Set();
+        const { included, excluded } = splitPatterns(jsPatterns);
+        for (const pattern of included) {
+          for (const dir of await expandPattern(absRootDir, pattern)) {
+            matchedDirs.add(dir);
           }
         }
-      } else {
-        const exactDir = join(absRootDir, pattern);
-        if (await dirExists(exactDir)) {
-          matchedDirs.add(exactDir);
+        for (const pattern of excluded) {
+          for (const dir of await expandPattern(absRootDir, pattern)) {
+            matchedDirs.delete(dir);
+          }
+        }
+        for (const dir of matchedDirs) {
+          const manifestPath = join2(dir, "package.json");
+          if (await fileExists2(manifestPath)) {
+            try {
+              const content = await readFile2(manifestPath, "utf8");
+              const manifest = JSON.parse(content);
+              if (!manifest.name) {
+                skipped.push({ directory: dir, reason: "package.json names no package" });
+              } else if (!manifest.version) {
+                skipped.push({
+                  directory: dir,
+                  name: manifest.name,
+                  reason: "package.json declares no version"
+                });
+              }
+              if (manifest.name && manifest.version) {
+                allPackages.push({
+                  name: manifest.name,
+                  version: manifest.version,
+                  directory: dir,
+                  manifestPath,
+                  manifest,
+                  isPrivate: !!manifest.private,
+                  relativeDir: relative(absRootDir, dir),
+                  ecosystem: "npm"
+                });
+              }
+            } catch {
+            }
+          }
         }
       }
     }
-    const packages = [];
-    for (const dir of matchedDirs) {
-      const manifestPath = join(dir, "package.json");
-      if (await fileExists(manifestPath)) {
-        try {
-          const content = await readFile(manifestPath, "utf8");
-          const manifest = JSON.parse(content);
-          if (manifest.name && manifest.version) {
-            packages.push({
-              name: manifest.name,
-              version: manifest.version,
-              directory: dir,
-              manifestPath,
-              manifest,
-              isPrivate: !!manifest.private,
-              relativeDir: relative(absRootDir, dir)
-            });
+    if (await fileExists2(rootCargoTomlPath)) {
+      try {
+        const rootCargoRaw = await readFile2(rootCargoTomlPath, "utf8");
+        const rootCargo = parseToml2(rootCargoRaw);
+        const workspaceDefaultVersion = rootCargo.workspace?.package?.version || rootCargo.package?.version || "0.1.0";
+        let cargoPatterns = [];
+        if (rootCargo.workspace && Array.isArray(rootCargo.workspace.members)) {
+          cargoPatterns = rootCargo.workspace.members;
+        }
+        if (rootCargo.package && rootCargo.package.name) {
+          const pkgName = rootCargo.package.name;
+          const pkgVersion = typeof rootCargo.package.version === "string" ? rootCargo.package.version : workspaceDefaultVersion;
+          const isPrivate = rootCargo.package.publish === false;
+          const manifest = {
+            name: pkgName,
+            version: pkgVersion,
+            private: isPrivate,
+            dependencies: extractCargoDeps(rootCargo.dependencies),
+            devDependencies: extractCargoDeps(rootCargo["dev-dependencies"])
+          };
+          allPackages.push({
+            name: pkgName,
+            version: pkgVersion,
+            directory: absRootDir,
+            manifestPath: rootCargoTomlPath,
+            manifest,
+            isPrivate,
+            relativeDir: ".",
+            ecosystem: "cargo"
+          });
+        }
+        if (cargoPatterns.length > 0) {
+          const matchedCrateDirs = /* @__PURE__ */ new Set();
+          for (const pattern of cargoPatterns) {
+            if (pattern.endsWith("/*")) {
+              const baseDir = join2(absRootDir, pattern.slice(0, -2));
+              if (await dirExists(baseDir)) {
+                const entries = await readdir(baseDir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.isDirectory()) {
+                    matchedCrateDirs.add(join2(baseDir, entry.name));
+                  }
+                }
+              }
+            } else {
+              const exactDir = join2(absRootDir, pattern);
+              if (await dirExists(exactDir)) {
+                matchedCrateDirs.add(exactDir);
+              }
+            }
+          }
+          for (const dir of matchedCrateDirs) {
+            const manifestPath = join2(dir, "Cargo.toml");
+            if (manifestPath === rootCargoTomlPath)
+              continue;
+            if (await fileExists2(manifestPath)) {
+              try {
+                const crateRaw = await readFile2(manifestPath, "utf8");
+                const crateParsed = parseToml2(crateRaw);
+                if (crateParsed.package && crateParsed.package.name) {
+                  const name = crateParsed.package.name;
+                  let version2 = crateParsed.package.version;
+                  if (typeof version2 !== "string") {
+                    version2 = workspaceDefaultVersion;
+                  }
+                  const isPrivate = crateParsed.package.publish === false;
+                  const manifest = {
+                    name,
+                    version: version2,
+                    private: isPrivate,
+                    dependencies: extractCargoDeps(crateParsed.dependencies),
+                    devDependencies: extractCargoDeps(crateParsed["dev-dependencies"])
+                  };
+                  allPackages.push({
+                    name,
+                    version: version2,
+                    directory: dir,
+                    manifestPath,
+                    manifest,
+                    isPrivate,
+                    relativeDir: relative(absRootDir, dir),
+                    ecosystem: "cargo"
+                  });
+                }
+              } catch {
+              }
+            }
           }
-        } catch {
         }
+        if (!ecosystems.includes("cargo")) {
+          ecosystems.push("cargo");
+        }
+        if (detectedPackageManager === "unknown") {
+          detectedPackageManager = "cargo";
+        }
+      } catch {
       }
     }
-    const graph = new PackageGraphImpl(packages);
+    const graph = new PackageGraphImpl(allPackages);
     return {
       rootDirectory: absRootDir,
-      packageManager,
-      packages,
-      graph
+      packageManager: detectedPackageManager,
+      packages: allPackages,
+      ...skipped.length > 0 ? { skipped } : {},
+      graph,
+      ecosystems
     };
   }
 };
+function splitPatterns(patterns) {
+  const included = [];
+  const excluded = [];
+  for (const raw of patterns) {
+    const pattern = raw.trim();
+    if (!pattern)
+      continue;
+    if (pattern.startsWith("!"))
+      excluded.push(pattern.slice(1));
+    else
+      included.push(pattern);
+  }
+  return { included, excluded };
+}
+var NEVER_A_PACKAGE = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+async function expandPattern(root, pattern) {
+  const segments = pattern.split("/").filter((segment) => segment !== "" && segment !== ".");
+  let current = [root];
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    const next = /* @__PURE__ */ new Set();
+    if (segment === "**") {
+      const remaining = segments.slice(index + 1);
+      for (const dir of current) {
+        for (const descendant of await descendants(dir))
+          next.add(descendant);
+      }
+      current = [...next];
+      if (remaining.length === 0)
+        return current;
+      const results = /* @__PURE__ */ new Set();
+      for (const dir of current) {
+        for (const match of await expandPattern(dir, remaining.join("/")))
+          results.add(match);
+      }
+      return [...results];
+    }
+    for (const dir of current) {
+      if (segment.includes("*")) {
+        const matches = segmentMatcher(segment);
+        let entries;
+        try {
+          entries = await readdir(dir, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          if (NEVER_A_PACKAGE.has(entry.name))
+            continue;
+          if (matches(entry.name))
+            next.add(join2(dir, entry.name));
+        }
+      } else {
+        const candidate = join2(dir, segment);
+        if (await dirExists(candidate))
+          next.add(candidate);
+      }
+    }
+    current = [...next];
+    if (current.length === 0)
+      return [];
+  }
+  return current;
+}
+async function descendants(root, maxDepth = 8) {
+  const found = [root];
+  const queue = [{ dir: root, depth: 0 }];
+  while (queue.length > 0) {
+    const { dir, depth } = queue.shift();
+    if (depth >= maxDepth)
+      continue;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || NEVER_A_PACKAGE.has(entry.name))
+        continue;
+      const child = join2(dir, entry.name);
+      found.push(child);
+      queue.push({ dir: child, depth: depth + 1 });
+    }
+  }
+  return found;
+}
+function segmentMatcher(segment) {
+  const source = segment.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/gu, "\\$&")).join("[^/]*");
+  const expression = new RegExp(`^${source}$`, "u");
+  return (name) => expression.test(name);
+}
 
 // ../workspace/dist/propagator.js
 import semver from "semver";
@@ -380,9 +849,11 @@ var DefaultSemVerDecisionEngine = class {
     const reasons = [];
     let confidenceSum = 0;
     let confidenceCount = 0;
-    const majorEvidence = evidence.filter((e) => e.severity === "major");
-    const minorEvidence = evidence.filter((e) => e.severity === "minor");
-    const patchEvidence = evidence.filter((e) => e.severity === "patch");
+    const blockingEvidence = evidence.filter((e) => e.blocking === true);
+    const gradingEvidence = evidence.filter((e) => e.blocking !== true);
+    const majorEvidence = gradingEvidence.filter((e) => e.severity === "major");
+    const minorEvidence = gradingEvidence.filter((e) => e.severity === "minor");
+    const patchEvidence = gradingEvidence.filter((e) => e.severity === "patch");
     if (majorEvidence.length > 0) {
       if (isZeroMajor && policy.zeroMajor?.breaking === "minor") {
         bump = "minor";
@@ -416,10 +887,16 @@ var DefaultSemVerDecisionEngine = class {
       bump = "none";
       reasons.push("No compatibility changes detected requiring a version bump.");
     }
+    if (blockingEvidence.length > 0) {
+      reasons.unshift(`Release blocked by ${blockingEvidence.length} finding(s); the version below is not proposed until they clear:`);
+      for (const e of blockingEvidence) {
+        reasons.splice(1, 0, `  - [${e.source}] ${e.title}`);
+      }
+    }
     const confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 1;
-    return this.createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel);
+    return this.createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel, blockingEvidence.length > 0);
   }
-  createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel) {
+  createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel, blocked = false) {
     let proposedVersion = currentVersion;
     if (bump !== "none") {
       if (channel && channel !== "stable") {
@@ -427,6 +904,9 @@ var DefaultSemVerDecisionEngine = class {
         const currentPrerelease = parsed.prerelease;
         if (currentPrerelease.length > 0 && currentPrerelease[0] === channel) {
           proposedVersion = semver2.inc(currentVersion, "prerelease", channel) || currentVersion;
+        } else if (currentPrerelease.length > 0) {
+          const promoted = `${parsed.major}.${parsed.minor}.${parsed.patch}-${channel}.0`;
+          proposedVersion = semver2.gt(promoted, currentVersion) ? promoted : semver2.inc(currentVersion, `pre${bump}`, channel) || currentVersion;
         } else {
           const baseBump = `pre${bump}`;
           proposedVersion = semver2.inc(currentVersion, baseBump, channel) || currentVersion;
@@ -444,14 +924,15 @@ var DefaultSemVerDecisionEngine = class {
       confidence,
       reasons,
       evidence,
-      requiresApproval
+      requiresApproval,
+      ...blocked ? { blocked: true } : {}
     };
   }
 };
 
 // ../contracts/dist/store.js
-import { readFile as readFile2, writeFile, mkdir, readdir as readdir2 } from "fs/promises";
-import { join as join2 } from "path";
+import { readFile as readFile3, writeFile as writeFile2, mkdir, readdir as readdir2 } from "fs/promises";
+import { join as join3 } from "path";
 import semver3 from "semver";
 var FileContractStore = class {
   directory;
@@ -471,9 +952,9 @@ var FileContractStore = class {
       const files = await readdir2(this.directory, { recursive: true });
       for (const file of files) {
         if (typeof file === "string" && file.endsWith(".json")) {
-          const fullPath = join2(this.directory, file);
+          const fullPath = join3(this.directory, file);
           try {
-            const content = await readFile2(fullPath, "utf8");
+            const content = await readFile3(fullPath, "utf8");
             const parsed = JSON.parse(content);
             if (!packageName || parsed.package === packageName) {
               contracts.push(parsed);
@@ -494,8 +975,8 @@ var FileContractStore = class {
     await this.ensureDir();
     const sanitizedPackage = contract.package.replace(/[^a-zA-Z0-9_-]/g, "_");
     const sanitizedId = contract.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const filePath = join2(this.directory, `${sanitizedPackage}__${sanitizedId}.json`);
-    await writeFile(filePath, JSON.stringify(contract, null, 2), "utf8");
+    const filePath = join3(this.directory, `${sanitizedPackage}__${sanitizedId}.json`);
+    await writeFile2(filePath, JSON.stringify(contract, null, 2), "utf8");
   }
   async getActiveContracts(packageName, targetVersion) {
     const all = await this.listContracts(packageName);
@@ -519,20 +1000,20 @@ var FileContractStore = class {
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { mkdtemp, rm, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { tmpdir } from "os";
 import * as tar from "tar";
 var execFileAsync = promisify(execFile);
 var CandidatePacker = class {
-  async pack(packageDir, packageName, version) {
-    const tempDir = await mkdtemp(join3(tmpdir(), "verelease-candidate-"));
+  async pack(packageDir, packageName, version2) {
+    const tempDir = await mkdtemp(join4(tmpdir(), "verelease-candidate-"));
     const tarballDest = tempDir;
     const { stdout } = await execFileAsync("npm", ["pack", "--pack-destination", tarballDest], {
       cwd: packageDir
     });
     const tarballFilename = stdout.trim().split("\n").pop().trim();
-    const tarballPath = join3(tarballDest, tarballFilename);
-    const unpackedDir = join3(tempDir, "unpacked");
+    const tarballPath = join4(tarballDest, tarballFilename);
+    const unpackedDir = join4(tempDir, "unpacked");
     await mkdir2(unpackedDir, { recursive: true });
     await tar.x({
       file: tarballPath,
@@ -542,14 +1023,15 @@ var CandidatePacker = class {
     });
     return {
       packageName,
-      version,
+      version: version2,
       tarballPath,
-      unpackedDir
+      unpackedDir,
+      sourceDir: packageDir
     };
   }
   async cleanup(packResult) {
     try {
-      const parentDir = join3(packResult.unpackedDir, "..");
+      const parentDir = join4(packResult.unpackedDir, "..");
       await rm(parentDir, { recursive: true, force: true });
     } catch {
     }
@@ -557,15 +1039,15 @@ var CandidatePacker = class {
 };
 
 // ../contracts/dist/runner.js
-import { mkdir as mkdir3, symlink, rm as rm2, writeFile as writeFile2, copyFile } from "fs/promises";
-import { join as join5, basename } from "path";
+import { access, cp, mkdir as mkdir3, symlink, rm as rm2, readFile as readFile5, writeFile as writeFile3, copyFile } from "fs/promises";
+import { join as join6, dirname, basename } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { mkdtemp as mkdtemp2 } from "fs/promises";
 
 // ../test-adapter-node/dist/node-test.js
 import { spawn } from "child_process";
-import { readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
 var NodeTestAdapter = class {
   options;
   name = "node:test";
@@ -579,6 +1061,11 @@ var NodeTestAdapter = class {
     if (hasNodeTestScript) {
       return { supported: true, confidence: 0.95 };
     }
+    const testScript = scripts.test ?? "";
+    const otherRunner = /\b(vitest|jest|playwright|bun\s+test|deno\s+test|ava|mocha)\b/u;
+    if (otherRunner.test(testScript)) {
+      return { supported: false, confidence: 0 };
+    }
     if (hasTestFiles) {
       return { supported: true, confidence: 0.7 };
     }
@@ -592,15 +1079,13 @@ var NodeTestAdapter = class {
     let testFiles = ctx.testFiles && ctx.testFiles.length > 0 ? ctx.testFiles : [];
     if (loaderArgs.length === 0 || testFiles.length === 0) {
       try {
-        const pkgRaw = await readFile3(join4(ctx.packagePath, "package.json"), "utf8");
+        const pkgRaw = await readFile4(join5(ctx.packagePath, "package.json"), "utf8");
         const pkg = JSON.parse(pkgRaw);
-        const testScript = pkg.scripts?.test || "";
-        if (loaderArgs.length === 0 && (testScript.includes("--import tsx") || testScript.includes("tsx"))) {
-          loaderArgs = ["--import", "tsx"];
-        }
-        if (testFiles.length === 0 && testScript.includes("src/**/*.test.ts")) {
-          testFiles = ["src/**/*.test.ts"];
-        }
+        const parsed = parseNodeTestScript(pkg.scripts?.test ?? "");
+        if (loaderArgs.length === 0)
+          loaderArgs = parsed.loaderArgs;
+        if (testFiles.length === 0)
+          testFiles = parsed.testFiles;
       } catch {
       }
     }
@@ -757,6 +1242,64 @@ var NodeTestAdapter = class {
     };
   }
 };
+function parseNodeTestScript(script) {
+  const empty = { loaderArgs: [], testFiles: [] };
+  if (!script.includes("--test"))
+    return empty;
+  const segment = script.split(/&&|;/u).map((part) => part.trim()).find((part) => /(^|\s)node\s/u.test(part) && part.includes("--test"));
+  if (!segment)
+    return empty;
+  const tokens = tokenize(segment);
+  const start = tokens.findIndex((token) => token === "--test");
+  if (start === -1)
+    return empty;
+  const loaderArgs = [];
+  const testFiles = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if ((token === "--import" || token === "--loader") && tokens[index + 1]) {
+      loaderArgs.push(token, tokens[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--import=") || token.startsWith("--loader=")) {
+      loaderArgs.push(token);
+      continue;
+    }
+    if (index > start && !token.startsWith("-")) {
+      testFiles.push(token);
+    }
+  }
+  return { loaderArgs, testFiles };
+}
+function tokenize(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const character of command) {
+    if (quote) {
+      if (character === quote)
+        quote = null;
+      else
+        current += character;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (/\s/u.test(character)) {
+      if (current)
+        tokens.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current)
+    tokens.push(current);
+  return tokens;
+}
 
 // ../contracts/dist/runner.js
 var ContractRunner = class {
@@ -764,24 +1307,74 @@ var ContractRunner = class {
   constructor(testAdapter = new NodeTestAdapter()) {
     this.testAdapter = testAdapter;
   }
+  /**
+   * Links the candidate's declared dependencies into the consumer.
+   *
+   * Resolution walks up from the source directory, so it works with pnpm's
+   * per-package symlinks and with hoisted layouts alike. A dependency that
+   * cannot be found is left out: the resulting import error is a more useful
+   * signal than a silent substitution.
+   */
+  async linkDependencies(candidate, nodeModulesDir) {
+    if (!candidate.sourceDir)
+      return;
+    let manifest;
+    try {
+      manifest = JSON.parse(await readFile5(join6(candidate.unpackedDir, "package.json"), "utf8"));
+    } catch {
+      return;
+    }
+    const names = Object.keys({
+      ...manifest.dependencies,
+      ...manifest.optionalDependencies
+    });
+    for (const name of names) {
+      const resolved = await this.resolveFrom(name, candidate.sourceDir);
+      if (!resolved)
+        continue;
+      const linkPath = join6(nodeModulesDir, ...name.split("/"));
+      await mkdir3(dirname(linkPath), { recursive: true });
+      try {
+        await symlink(resolved, linkPath, "junction");
+      } catch {
+      }
+    }
+  }
+  /** Finds an installed package by walking `node_modules` up from a directory. */
+  async resolveFrom(name, fromDir) {
+    let dir = fromDir;
+    for (; ; ) {
+      const candidatePath = join6(dir, "node_modules", ...name.split("/"));
+      try {
+        await access(candidatePath);
+        return candidatePath;
+      } catch {
+      }
+      const parent = dirname(dir);
+      if (parent === dir)
+        return null;
+      dir = parent;
+    }
+  }
   async runContract(contract, candidate) {
     const startTime = Date.now();
-    const consumerEnvDir = await mkdtemp2(join5(tmpdir2(), "verelease-consumer-"));
-    const nodeModulesDir = join5(consumerEnvDir, "node_modules");
+    const consumerEnvDir = await mkdtemp2(join6(tmpdir2(), "verelease-consumer-"));
+    const nodeModulesDir = join6(consumerEnvDir, "node_modules");
     try {
-      await writeFile2(join5(consumerEnvDir, "package.json"), JSON.stringify({ name: "consumer-fixture", type: "module" }, null, 2), "utf8");
-      let targetPkgLink = join5(nodeModulesDir, candidate.packageName);
+      await writeFile3(join6(consumerEnvDir, "package.json"), JSON.stringify({ name: "consumer-fixture", type: "module" }, null, 2), "utf8");
+      let targetPkgLink = join6(nodeModulesDir, candidate.packageName);
       if (candidate.packageName.startsWith("@")) {
         const [scope, pkgName] = candidate.packageName.split("/");
-        const scopeDir = join5(nodeModulesDir, scope);
+        const scopeDir = join6(nodeModulesDir, scope);
         await mkdir3(scopeDir, { recursive: true });
-        targetPkgLink = join5(scopeDir, pkgName);
+        targetPkgLink = join6(scopeDir, pkgName);
       } else {
         await mkdir3(nodeModulesDir, { recursive: true });
       }
-      await symlink(candidate.unpackedDir, targetPkgLink, "junction");
+      await cp(candidate.unpackedDir, targetPkgLink, { recursive: true });
+      await this.linkDependencies(candidate, nodeModulesDir);
       const isolatedTestName = basename(contract.testFile);
-      const isolatedTestPath = join5(consumerEnvDir, isolatedTestName);
+      const isolatedTestPath = join6(consumerEnvDir, isolatedTestName);
       await copyFile(contract.testFile, isolatedTestPath);
       const testRun = await this.testAdapter.run({
         packagePath: consumerEnvDir,
@@ -862,24 +1455,122 @@ var ContractCompatibilityAnalyzer = class {
 };
 
 // ../api-diff/dist/extractor.js
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
+import { dirname as dirname2, join as join7, resolve as resolvePath } from "path";
 import ts from "typescript";
 var ApiExtractor = class {
-  extractFromSource(sourceCode, fileName = "index.ts") {
-    const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  /**
+   * The full public surface reachable from an entry point, following
+   * `export ... from` through the package.
+   *
+   * Every package here is published behind a barrel — `src/index.ts` is often
+   * nothing but `export * from "./engine.js"` — so parsing the entry point
+   * alone reports no API at all, and a diff of nothing against nothing finds
+   * no change however good the baseline is.
+   *
+   * Only relative specifiers are followed. A bare specifier is another
+   * package's surface, and changes there are that package's business, not a
+   * change to this one's API.
+   */
+  async extractFromEntrypoint(entryPath, options = {}) {
+    const maxDepth = options.maxDepth ?? 16;
     const exports = {};
-    const visit = (node) => {
-      const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
-      const isExported = (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || !!modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      if (ts.isFunctionDeclaration(node) && node.name && isExported) {
-        const fnName = node.name.text;
-        const parameters = node.parameters.map((param) => {
-          return {
-            name: param.name.getText(sourceFile),
-            isOptional: !!param.questionToken || !!param.initializer,
-            typeString: param.type ? param.type.getText(sourceFile) : "any"
-          };
-        });
-        exports[fnName] = {
+    const visited = /* @__PURE__ */ new Set();
+    const walk = async (filePath, depth) => {
+      const key = resolvePath(filePath);
+      if (visited.has(key) || depth > maxDepth)
+        return;
+      visited.add(key);
+      let source;
+      try {
+        source = await readFile6(key, "utf8");
+      } catch {
+        return;
+      }
+      const snapshot = this.extractFromSource(source, key);
+      for (const [name, symbol] of Object.entries(snapshot.exports)) {
+        exports[name] ??= symbol;
+      }
+      for (const reExport of snapshot.reExports ?? []) {
+        if (!reExport.specifier.startsWith("."))
+          continue;
+        const target = await this.resolveRelative(reExport.specifier, dirname2(key));
+        if (!target)
+          continue;
+        if (reExport.namespaceAlias) {
+          exports[reExport.namespaceAlias] ??= {
+            kind: "variable",
+            name: reExport.namespaceAlias,
+            typeString: `typeof import(${JSON.stringify(reExport.specifier)})`
+          };
+          continue;
+        }
+        const before = new Set(Object.keys(exports));
+        await walk(target, depth + 1);
+        if (reExport.names) {
+          const wanted = new Map(reExport.names.map((n) => [n.local, n.exported]));
+          for (const name of Object.keys(exports)) {
+            if (before.has(name))
+              continue;
+            const exportedAs = wanted.get(name);
+            if (exportedAs === void 0) {
+              delete exports[name];
+            } else if (exportedAs !== name) {
+              exports[exportedAs] = { ...exports[name], name: exportedAs };
+              delete exports[name];
+            }
+          }
+        }
+      }
+    };
+    await walk(entryPath, 0);
+    return { exports };
+  }
+  /**
+   * Maps an ESM specifier to a file on disk.
+   *
+   * TypeScript sources import with a `.js` extension that only exists after a
+   * build, so the declared path is rarely the path to read.
+   */
+  async resolveRelative(specifier, fromDir) {
+    const base = join7(fromDir, specifier);
+    const withoutJs = base.replace(/\.js$/u, "");
+    const candidates = [
+      base.endsWith(".ts") ? base : null,
+      `${withoutJs}.ts`,
+      `${withoutJs}.d.ts`,
+      `${withoutJs}.tsx`,
+      base,
+      join7(base, "index.ts"),
+      join7(base, "index.d.ts"),
+      join7(withoutJs, "index.ts")
+    ].filter((c) => c !== null);
+    for (const candidate of candidates) {
+      try {
+        if ((await stat3(candidate)).isFile())
+          return candidate;
+      } catch {
+      }
+    }
+    return null;
+  }
+  extractFromSource(sourceCode, fileName = "index.ts") {
+    const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const exports = {};
+    const reExports = [];
+    const visit = (node) => {
+      const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+      const isExported = (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || !!modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (ts.isFunctionDeclaration(node) && node.name && isExported) {
+        const fnName = node.name.text;
+        const parameters = node.parameters.map((param) => {
+          return {
+            name: param.name.getText(sourceFile),
+            isOptional: !!param.questionToken || !!param.initializer,
+            typeString: param.type ? param.type.getText(sourceFile) : "any"
+          };
+        });
+        exports[fnName] = {
           kind: "function",
           name: fnName,
           parameters,
@@ -949,11 +1640,45 @@ var ApiExtractor = class {
           name: ifaceName,
           properties
         };
+      } else if (ts.isTypeAliasDeclaration(node) && node.name && isExported) {
+        const aliasName = node.name.text;
+        exports[aliasName] = {
+          kind: "type",
+          name: aliasName,
+          typeString: node.type.getText(sourceFile)
+        };
+      } else if (ts.isEnumDeclaration(node) && node.name && isExported) {
+        const enumName = node.name.text;
+        const members = {};
+        for (const member of node.members) {
+          const memberName = member.name.getText(sourceFile);
+          members[memberName] = {
+            name: memberName,
+            ...member.initializer ? { value: member.initializer.getText(sourceFile) } : {}
+          };
+        }
+        exports[enumName] = { kind: "enum", name: enumName, members };
+      }
+      if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        const specifier = node.moduleSpecifier.text;
+        if (!node.exportClause) {
+          reExports.push({ specifier });
+        } else if (ts.isNamespaceExport(node.exportClause)) {
+          reExports.push({ specifier, namespaceAlias: node.exportClause.name.text });
+        } else if (ts.isNamedExports(node.exportClause)) {
+          reExports.push({
+            specifier,
+            names: node.exportClause.elements.map((el) => ({
+              local: (el.propertyName ?? el.name).text,
+              exported: el.name.text
+            }))
+          });
+        }
       }
       ts.forEachChild(node, visit);
     };
     ts.forEachChild(sourceFile, visit);
-    return { exports };
+    return reExports.length > 0 ? { exports, reExports } : { exports };
   }
 };
 
@@ -993,6 +1718,12 @@ var ApiDiffEngine = class {
         this.diffFunction(packageName, name, baseSym, candSym, evidence);
       } else if (baseSym.kind === "interface" && candSym.kind === "interface") {
         this.diffInterface(packageName, name, baseSym, candSym, evidence);
+      } else if (baseSym.kind === "class" && candSym.kind === "class") {
+        this.diffClass(packageName, name, baseSym, candSym, evidence);
+      } else if (baseSym.kind === "type" && candSym.kind === "type") {
+        this.diffTypeAlias(packageName, name, baseSym, candSym, evidence);
+      } else if (baseSym.kind === "enum" && candSym.kind === "enum") {
+        this.diffEnum(packageName, name, baseSym, candSym, evidence);
       }
     }
     for (const [name, candSym] of Object.entries(candidateExports)) {
@@ -1075,6 +1806,112 @@ var ApiDiffEngine = class {
       }
     }
   }
+  /**
+   * Compares the members of an exported class.
+   *
+   * The extractor has always captured methods and properties, but only
+   * interfaces were compared, so a class could gain or lose public methods
+   * without any evidence being produced — the export was still there, so the
+   * package looked unchanged.
+   */
+  diffClass(packageName, className, baseClass, candClass, evidence) {
+    for (const memberKind of ["methods", "properties"]) {
+      const before = baseClass[memberKind];
+      const after = candClass[memberKind];
+      const singular = memberKind === "methods" ? "method" : "property";
+      for (const memberName of Object.keys(before)) {
+        if (!after[memberName]) {
+          evidence.push({
+            id: `api.class.${singular}Removed:${className}:${memberName}`,
+            package: packageName,
+            source: "api",
+            severity: "major",
+            confidence: 0.95,
+            title: `Public ${singular} removed from class: ${className}.${memberName}`,
+            description: `Class "${className}" no longer exposes ${singular} "${memberName}". Callers of it break.`
+          });
+        }
+      }
+      for (const memberName of Object.keys(after)) {
+        if (!before[memberName]) {
+          evidence.push({
+            id: `api.class.${singular}Added:${className}:${memberName}`,
+            package: packageName,
+            source: "api",
+            severity: "minor",
+            confidence: 0.9,
+            title: `Public ${singular} added to class: ${className}.${memberName}`,
+            description: `Class "${className}" gained ${singular} "${memberName}".`
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Compares an exported type alias.
+   *
+   * Reported with reduced confidence, because a definition change can go
+   * either way and telling them apart needs the type checker rather than the
+   * syntax: widening a union is safe for code that reads the type and breaking
+   * for code that implements it, and narrowing breaks both. Calling it
+   * breaking and saying why is more useful than staying silent, and the
+   * confidence lets a policy hold it for review.
+   */
+  diffTypeAlias(packageName, typeName, baseAlias, candAlias, evidence) {
+    if (baseAlias.typeString === candAlias.typeString)
+      return;
+    evidence.push({
+      id: `api.type.changed:${typeName}`,
+      package: packageName,
+      source: "types",
+      severity: "major",
+      confidence: 0.6,
+      title: `Exported type changed: ${typeName}`,
+      description: `Type "${typeName}" changed from "${baseAlias.typeString}" to "${candAlias.typeString}". A narrowing breaks consumers; a widening may only break those implementing it.`
+    });
+  }
+  /** Compares the members of an exported enum. */
+  diffEnum(packageName, enumName, baseEnum, candEnum, evidence) {
+    for (const [memberName, member] of Object.entries(baseEnum.members)) {
+      if (!candEnum.members[memberName]) {
+        evidence.push({
+          id: `api.enum.memberRemoved:${enumName}:${memberName}`,
+          package: packageName,
+          source: "types",
+          severity: "major",
+          confidence: 0.95,
+          title: `Enum member removed: ${enumName}.${memberName}`,
+          description: `Enum "${enumName}" no longer declares "${memberName}".`
+        });
+        continue;
+      }
+      const candValue = candEnum.members[memberName].value;
+      if (member.value !== void 0 && candValue !== void 0 && member.value !== candValue) {
+        evidence.push({
+          id: `api.enum.valueChanged:${enumName}:${memberName}`,
+          package: packageName,
+          source: "types",
+          severity: "major",
+          confidence: 0.9,
+          title: `Enum value changed: ${enumName}.${memberName}`,
+          description: `"${enumName}.${memberName}" changed from ${member.value} to ${candValue}.`
+        });
+      }
+    }
+    for (const memberName of Object.keys(candEnum.members)) {
+      if (!baseEnum.members[memberName]) {
+        evidence.push({
+          id: `api.enum.memberAdded:${enumName}:${memberName}`,
+          package: packageName,
+          source: "types",
+          severity: "minor",
+          confidence: 0.9,
+          title: `Enum member added: ${enumName}.${memberName}`,
+          description: `Enum "${enumName}" gained "${memberName}".`
+        });
+      }
+    }
+  }
   diffInterface(packageName, ifaceName, baseIface, candIface, evidence) {
     for (const [propName, prop] of Object.entries(baseIface.properties)) {
       if (!candIface.properties[propName]) {
@@ -1118,11 +1955,11 @@ var ApiDiffEngine = class {
 };
 
 // ../api-diff/dist/analyzer.js
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
-async function fileExists2(path) {
+import { readFile as readFile7, stat as stat4 } from "fs/promises";
+import { join as join8 } from "path";
+async function fileExists3(path) {
   try {
-    const s = await stat2(path);
+    const s = await stat4(path);
     return s.isFile();
   } catch {
     return false;
@@ -1141,15 +1978,14 @@ var ApiDiffAnalyzer = class {
     if (!candidateEntrypoint) {
       return [];
     }
-    const candidateSource = await readFile4(candidateEntrypoint, "utf8");
-    const candidateSnapshot = this.extractor.extractFromSource(candidateSource, candidateEntrypoint);
+    const candidateSnapshot = await this.extractor.extractFromEntrypoint(candidateEntrypoint);
     let baselineSnapshot;
-    if (context.baselinePath && await fileExists2(context.baselinePath)) {
-      const baseSource = await readFile4(context.baselinePath, "utf8");
+    if (context.baselinePath && await fileExists3(context.baselinePath)) {
+      const baseSource = await readFile7(context.baselinePath, "utf8");
       if (context.baselinePath.endsWith(".json")) {
         baselineSnapshot = JSON.parse(baseSource);
       } else {
-        baselineSnapshot = this.extractor.extractFromSource(baseSource, context.baselinePath);
+        baselineSnapshot = await this.extractor.extractFromEntrypoint(context.baselinePath);
       }
     }
     if (!baselineSnapshot) {
@@ -1159,14 +1995,14 @@ var ApiDiffAnalyzer = class {
   }
   async findEntrypoint(pkgDir) {
     const candidates = [
-      join6(pkgDir, "src", "index.ts"),
-      join6(pkgDir, "src", "index.js"),
-      join6(pkgDir, "index.ts"),
-      join6(pkgDir, "index.js"),
-      join6(pkgDir, "dist", "index.d.ts")
+      join8(pkgDir, "src", "index.ts"),
+      join8(pkgDir, "src", "index.js"),
+      join8(pkgDir, "index.ts"),
+      join8(pkgDir, "index.js"),
+      join8(pkgDir, "dist", "index.d.ts")
     ];
     for (const c of candidates) {
-      if (await fileExists2(c)) {
+      if (await fileExists3(c)) {
         return c;
       }
     }
@@ -1177,14 +2013,14 @@ var ApiDiffAnalyzer = class {
 // ../api-diff/dist/baseline.js
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { mkdtemp as mkdtemp3, mkdir as mkdir4, stat as stat3 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdtemp as mkdtemp3, mkdir as mkdir4, stat as stat5 } from "fs/promises";
+import { join as join9 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import * as tar2 from "tar";
 var execFileAsync2 = promisify2(execFile2);
-async function fileExists3(path) {
+async function fileExists4(path) {
   try {
-    const s = await stat3(path);
+    const s = await stat5(path);
     return s.isFile();
   } catch {
     return false;
@@ -1199,20 +2035,20 @@ var BaselineFetcher = class {
    * or the extracted package has no recognizable entry point.
    */
   async fetch(packageName, parentTmpDir) {
-    const version = await this.getLatestVersion(packageName);
-    if (!version)
+    const version2 = await this.getLatestVersion(packageName);
+    if (!version2)
       return null;
-    const tempDir = parentTmpDir ? join7(parentTmpDir, packageName.replace(/\//g, "__")) : await mkdtemp3(join7(tmpdir3(), "verelease-baseline-"));
+    const tempDir = parentTmpDir ? join9(parentTmpDir, packageName.replace(/\//g, "__")) : await mkdtemp3(join9(tmpdir3(), "verelease-baseline-"));
     await mkdir4(tempDir, { recursive: true });
     let tarballFilename;
     try {
-      const { stdout } = await execFileAsync2("npm", ["pack", `${packageName}@${version}`, "--pack-destination", tempDir], { timeout: 3e4 });
+      const { stdout } = await execFileAsync2("npm", ["pack", `${packageName}@${version2}`, "--pack-destination", tempDir], { timeout: 3e4 });
       tarballFilename = stdout.trim().split("\n").pop().trim();
     } catch {
       return null;
     }
-    const tarballPath = join7(tempDir, tarballFilename);
-    const extractedDir = join7(tempDir, "extracted");
+    const tarballPath = join9(tempDir, tarballFilename);
+    const extractedDir = join9(tempDir, "extracted");
     await mkdir4(extractedDir, { recursive: true });
     try {
       await tar2.x({
@@ -1227,7 +2063,7 @@ var BaselineFetcher = class {
     const entryPointPath = await this.findEntrypoint(extractedDir);
     if (!entryPointPath)
       return null;
-    return { version, entryPointPath, extractedDir };
+    return { version: version2, entryPointPath, extractedDir };
   }
   async getLatestVersion(packageName) {
     try {
@@ -1242,16 +2078,16 @@ var BaselineFetcher = class {
   }
   async findEntrypoint(pkgDir) {
     const candidates = [
-      join7(pkgDir, "dist", "index.d.ts"),
-      join7(pkgDir, "dist", "index.d.mts"),
-      join7(pkgDir, "src", "index.ts"),
-      join7(pkgDir, "src", "index.js"),
-      join7(pkgDir, "index.d.ts"),
-      join7(pkgDir, "index.ts"),
-      join7(pkgDir, "index.js")
+      join9(pkgDir, "dist", "index.d.ts"),
+      join9(pkgDir, "dist", "index.d.mts"),
+      join9(pkgDir, "src", "index.ts"),
+      join9(pkgDir, "src", "index.js"),
+      join9(pkgDir, "index.d.ts"),
+      join9(pkgDir, "index.ts"),
+      join9(pkgDir, "index.js")
     ];
     for (const candidate of candidates) {
-      if (await fileExists3(candidate)) {
+      if (await fileExists4(candidate)) {
         return candidate;
       }
     }
@@ -1259,141 +2095,381 @@ var BaselineFetcher = class {
   }
 };
 
-// ../manifest/dist/mutator.js
-import { readFile as readFile5, writeFile as writeFile3, stat as stat4 } from "fs/promises";
-import { join as join8 } from "path";
-async function fileExists4(path) {
+// ../api-diff/dist/cargo-semver.js
+import { readFile as readFile8, stat as stat6 } from "fs/promises";
+import { join as join10 } from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+async function fileExists5(path) {
   try {
-    const s = await stat4(path);
+    const s = await stat6(path);
     return s.isFile();
   } catch {
     return false;
   }
 }
-var TransactionalManifestMutator = class {
-  async applyPlan(plan) {
-    const backups = [];
-    const modifiedFiles = [];
-    const filesToTouch = /* @__PURE__ */ new Set();
-    for (const pkgPlan of plan.packages) {
-      if (pkgPlan.bump !== "none") {
-        const pkgJson = join8(pkgPlan.directory, "package.json");
-        const jsrJson = join8(pkgPlan.directory, "jsr.json");
-        const denoJson = join8(pkgPlan.directory, "deno.json");
-        if (await fileExists4(pkgJson))
-          filesToTouch.add(pkgJson);
-        if (await fileExists4(jsrJson))
-          filesToTouch.add(jsrJson);
-        if (await fileExists4(denoJson))
-          filesToTouch.add(denoJson);
-      }
-      for (const update of pkgPlan.dependentUpdates) {
-        const depPkgPlan = plan.packages.find((p) => p.name === update.dependentName);
-        if (depPkgPlan) {
-          const depPkgJson = join8(depPkgPlan.directory, "package.json");
-          if (await fileExists4(depPkgJson))
-            filesToTouch.add(depPkgJson);
-        }
-      }
-    }
-    for (const filePath of filesToTouch) {
-      const originalContent = await readFile5(filePath, "utf8");
-      backups.push({ filePath, originalContent });
-    }
-    try {
-      const versionMap = /* @__PURE__ */ new Map();
-      for (const pkgPlan of plan.packages) {
-        if (pkgPlan.bump !== "none") {
-          versionMap.set(pkgPlan.name, pkgPlan.proposedVersion);
-        }
-      }
-      const depUpdateMap = /* @__PURE__ */ new Map();
-      for (const pkgPlan of plan.packages) {
-        for (const depUp of pkgPlan.dependentUpdates) {
-          if (!depUpdateMap.has(depUp.dependentName)) {
-            depUpdateMap.set(depUp.dependentName, []);
-          }
-          depUpdateMap.get(depUp.dependentName).push({
-            dependencyName: depUp.dependencyName,
-            newRange: depUp.newRange,
-            type: depUp.dependencyType
-          });
+function extractRustApiSnapshot(sourceCode, crateName, version2) {
+  const items = {};
+  const stripped = sourceCode.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "");
+  const fnRegex = /pub(?:\s+async)?(?:\s+const)?(?:\s+unsafe)?\s+fn\s+([a-zA-Z0-9_]+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)(?:\s*->\s*([^{;]+))?/g;
+  let match;
+  while ((match = fnRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    const params = match[2]?.trim() ?? "";
+    const returnType = match[3]?.trim() ?? "()";
+    items[`fn:${name}`] = {
+      kind: "fn",
+      name,
+      signature: `pub fn ${name}(${params}) -> ${returnType}`
+    };
+  }
+  const structRegex = /pub\s+struct\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?/g;
+  while ((match = structRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    items[`struct:${name}`] = {
+      kind: "struct",
+      name,
+      signature: `pub struct ${name}`
+    };
+  }
+  const enumRegex = /pub\s+enum\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?/g;
+  while ((match = enumRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    items[`enum:${name}`] = {
+      kind: "enum",
+      name,
+      signature: `pub enum ${name}`
+    };
+  }
+  const traitRegex = /pub\s+trait\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?/g;
+  while ((match = traitRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    items[`trait:${name}`] = {
+      kind: "trait",
+      name,
+      signature: `pub trait ${name}`
+    };
+  }
+  const typeRegex = /pub\s+type\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?\s*=\s*([^;]+);/g;
+  while ((match = typeRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    const target = match[2]?.trim() ?? "";
+    items[`type:${name}`] = {
+      kind: "type",
+      name,
+      signature: `pub type ${name} = ${target}`
+    };
+  }
+  const constRegex = /pub\s+const\s+([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_&<>\[\]]+)/g;
+  while ((match = constRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    const constType = match[2]?.trim() ?? "";
+    items[`const:${name}`] = {
+      kind: "const",
+      name,
+      signature: `pub const ${name}: ${constType}`
+    };
+  }
+  return {
+    crateName,
+    version: version2,
+    items
+  };
+}
+function diffRustApi(crateName, baseline, candidate) {
+  const evidence = [];
+  for (const [key, baseItem] of Object.entries(baseline.items)) {
+    const candItem = candidate.items[key];
+    if (!candItem) {
+      evidence.push({
+        id: `rust.api.removed:${crateName}:${baseItem.kind}:${baseItem.name}`,
+        package: crateName,
+        source: "api",
+        severity: "major",
+        confidence: 0.95,
+        title: `Removed public ${baseItem.kind}: ${baseItem.name}`,
+        description: `Breaking API change: The public ${baseItem.kind} '${baseItem.name}' was removed from ${crateName}.`,
+        metadata: {
+          itemKind: baseItem.kind,
+          itemName: baseItem.name,
+          previousSignature: baseItem.signature
         }
-      }
-      for (const pkgPlan of plan.packages) {
-        const pkgJsonPath = join8(pkgPlan.directory, "package.json");
-        if (filesToTouch.has(pkgJsonPath)) {
-          const content = await readFile5(pkgJsonPath, "utf8");
-          const parsed = JSON.parse(content);
-          if (versionMap.has(pkgPlan.name)) {
-            parsed.version = versionMap.get(pkgPlan.name);
-          }
-          const depUpdates = depUpdateMap.get(pkgPlan.name);
-          if (depUpdates) {
-            for (const up of depUpdates) {
-              const sec = parsed[up.type];
-              if (sec && sec[up.dependencyName]) {
-                sec[up.dependencyName] = up.newRange;
-              }
-            }
-          }
-          await writeFile3(pkgJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
-          modifiedFiles.push(pkgJsonPath);
+      });
+    } else if (baseItem.signature !== candItem.signature) {
+      evidence.push({
+        id: `rust.api.changed:${crateName}:${baseItem.kind}:${baseItem.name}`,
+        package: crateName,
+        source: "api",
+        severity: "major",
+        confidence: 0.9,
+        title: `Changed signature of ${baseItem.kind}: ${baseItem.name}`,
+        description: `Breaking API change: Signature changed from '${baseItem.signature}' to '${candItem.signature}'.`,
+        metadata: {
+          itemKind: baseItem.kind,
+          itemName: baseItem.name,
+          previousSignature: baseItem.signature,
+          newSignature: candItem.signature
         }
-        const jsrJsonPath = join8(pkgPlan.directory, "jsr.json");
-        if (filesToTouch.has(jsrJsonPath)) {
-          const content = await readFile5(jsrJsonPath, "utf8");
-          const parsed = JSON.parse(content);
-          if (versionMap.has(pkgPlan.name)) {
-            parsed.version = versionMap.get(pkgPlan.name);
-          }
-          await writeFile3(jsrJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
-          modifiedFiles.push(jsrJsonPath);
+      });
+    }
+  }
+  for (const [key, candItem] of Object.entries(candidate.items)) {
+    if (!baseline.items[key]) {
+      evidence.push({
+        id: `rust.api.added:${crateName}:${candItem.kind}:${candItem.name}`,
+        package: crateName,
+        source: "api",
+        severity: "minor",
+        confidence: 0.9,
+        title: `Added public ${candItem.kind}: ${candItem.name}`,
+        description: `Feature: New public ${candItem.kind} '${candItem.name}' added to ${crateName}.`,
+        metadata: {
+          itemKind: candItem.kind,
+          itemName: candItem.name,
+          newSignature: candItem.signature
         }
-        const denoJsonPath = join8(pkgPlan.directory, "deno.json");
-        if (filesToTouch.has(denoJsonPath)) {
-          const content = await readFile5(denoJsonPath, "utf8");
-          const parsed = JSON.parse(content);
-          if (versionMap.has(pkgPlan.name)) {
-            parsed.version = versionMap.get(pkgPlan.name);
-          }
-          await writeFile3(denoJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
-          modifiedFiles.push(denoJsonPath);
+      });
+    }
+  }
+  return evidence;
+}
+function parseCargoSemVerOutput(rawOutput, crateName) {
+  const evidence = [];
+  const lines = rawOutput.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("{"))
+      continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const ruleName = parsed.name || parsed.rule_name || "semver_check";
+      const isBreaking = parsed.category === "breaking" || parsed.level === "error" || parsed.severity === "error" || parsed.category === "Major";
+      const severity = isBreaking ? "major" : "minor";
+      const description = parsed.description || parsed.message || `Diagnostic from cargo-semver-checks (${ruleName})`;
+      evidence.push({
+        id: `cargo.semver.diagnostic:${crateName}:${ruleName}`,
+        package: crateName,
+        source: "api",
+        severity,
+        confidence: 0.98,
+        title: isBreaking ? `Cargo semver-checks breaking change: ${ruleName}` : `Cargo semver-checks non-breaking addition: ${ruleName}`,
+        description,
+        metadata: {
+          ruleName,
+          span: parsed.span,
+          rawDiagnostic: parsed
         }
+      });
+    } catch {
+    }
+  }
+  return evidence;
+}
+var CargoSemVerAnalyzer = class {
+  name = "cargo-semver-analyzer";
+  async analyze(context) {
+    const { packagePath, packageName } = context;
+    const cargoTomlPath = join10(packagePath, "Cargo.toml");
+    if (!await fileExists5(cargoTomlPath)) {
+      return [];
+    }
+    try {
+      const { stdout } = await execFileAsync3("cargo", [
+        "semver-checks",
+        "check-release",
+        "--manifest-path",
+        cargoTomlPath,
+        "--json",
+        ...context.baselinePath ? ["--baseline-root", context.baselinePath] : []
+      ], {
+        cwd: packagePath,
+        timeout: 6e4
+      });
+      const parsedEvidence = parseCargoSemVerOutput(stdout, packageName);
+      if (parsedEvidence.length > 0) {
+        return parsedEvidence;
       }
     } catch (err) {
-      for (const b of backups) {
-        await writeFile3(b.filePath, b.originalContent, "utf8");
-      }
-      throw err;
-    }
-    const transaction = {
-      id: `tx-${Date.now()}`,
-      plan,
-      backups,
-      modifiedFiles,
-      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      async rollback() {
-        for (const b of backups) {
-          await writeFile3(b.filePath, b.originalContent, "utf8");
+      const execError = err;
+      if (execError.stdout) {
+        const diagnostics = parseCargoSemVerOutput(execError.stdout, packageName);
+        if (diagnostics.length > 0) {
+          return diagnostics;
         }
-      },
-      async commit() {
+      }
+    }
+    const candidateEntrypoint = await this.findRustEntrypoint(packagePath);
+    if (!candidateEntrypoint) {
+      return [];
+    }
+    const candidateSource = await readFile8(candidateEntrypoint, "utf8");
+    const candidateSnapshot = extractRustApiSnapshot(candidateSource, packageName, context.currentVersion);
+    let baselineSnapshot;
+    if (context.baselinePath && await fileExists5(context.baselinePath)) {
+      const baseSource = await readFile8(context.baselinePath, "utf8");
+      if (context.baselinePath.endsWith(".json")) {
+        baselineSnapshot = JSON.parse(baseSource);
+      } else {
+        baselineSnapshot = extractRustApiSnapshot(baseSource, packageName, context.previousVersion);
+      }
+    } else if (context.baselinePath) {
+      const baseEntrypoint = await this.findRustEntrypoint(context.baselinePath);
+      if (baseEntrypoint && await fileExists5(baseEntrypoint)) {
+        const baseSource = await readFile8(baseEntrypoint, "utf8");
+        baselineSnapshot = extractRustApiSnapshot(baseSource, packageName, context.previousVersion);
+      }
+    }
+    if (!baselineSnapshot) {
+      return [];
+    }
+    return diffRustApi(packageName, baselineSnapshot, candidateSnapshot);
+  }
+  async findRustEntrypoint(dir) {
+    const candidates = [
+      join10(dir, "src", "lib.rs"),
+      join10(dir, "src", "main.rs"),
+      join10(dir, "lib.rs"),
+      join10(dir, "main.rs")
+    ];
+    for (const c of candidates) {
+      if (await fileExists5(c)) {
+        return c;
+      }
+    }
+    return null;
+  }
+};
+
+// ../api-diff/dist/git-baseline.js
+import { execFile as execFile4 } from "child_process";
+import { mkdtemp as mkdtemp4, readFile as readFile9, readdir as readdir3, rm as rm3, stat as stat7 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join11, relative as relative2 } from "path";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
+var GitBaselineResolver = class {
+  repoRoot;
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+  }
+  /**
+   * Checks out the last release of a package into a temporary worktree.
+   *
+   * Returns null when the package has never been released, which is not a
+   * failure: a first release has nothing to be compared against.
+   */
+  async resolve(packageName, packageDir) {
+    const ref = await this.lastReleaseTag(packageName);
+    if (!ref)
+      return null;
+    const worktree = await mkdtemp4(join11(tmpdir4(), "verelease-baseline-git-"));
+    const cleanup = async () => {
+      try {
+        await execFileAsync4("git", ["worktree", "remove", "--force", worktree], {
+          cwd: this.repoRoot
+        });
+      } catch {
+        await rm3(worktree, { recursive: true, force: true }).catch(() => void 0);
+        await execFileAsync4("git", ["worktree", "prune"], { cwd: this.repoRoot }).catch(() => void 0);
       }
     };
-    return transaction;
+    try {
+      await execFileAsync4("git", ["worktree", "add", "--detach", worktree, ref], {
+        cwd: this.repoRoot
+      });
+    } catch {
+      await cleanup();
+      return null;
+    }
+    const relativeDir = relative2(this.repoRoot, packageDir);
+    let baselineDir = join11(worktree, relativeDir);
+    let entryPointPath = await findEntrypoint(baselineDir);
+    if (!entryPointPath) {
+      baselineDir = await findPackageByName(worktree, packageName);
+      entryPointPath = baselineDir ? await findEntrypoint(baselineDir) : null;
+    }
+    if (!entryPointPath) {
+      await cleanup();
+      return null;
+    }
+    return { ref, entryPointPath, cleanup };
+  }
+  /** The newest tag naming this package, by either supported tag format. */
+  async lastReleaseTag(packageName) {
+    for (const pattern of [`${packageName}@*`, "v*"]) {
+      try {
+        const { stdout } = await execFileAsync4("git", ["tag", "--list", pattern, "--sort=-creatordate"], { cwd: this.repoRoot });
+        const [first] = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+        if (first)
+          return first;
+      } catch {
+        return null;
+      }
+    }
+    return null;
   }
 };
+async function findEntrypoint(pkgDir) {
+  const candidates = [
+    join11(pkgDir, "src", "index.ts"),
+    join11(pkgDir, "src", "index.js"),
+    join11(pkgDir, "index.ts"),
+    join11(pkgDir, "index.js"),
+    join11(pkgDir, "dist", "index.d.ts")
+  ];
+  for (const candidate of candidates) {
+    try {
+      if ((await stat7(candidate)).isFile())
+        return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function findPackageByName(root, packageName, maxDepth = 6) {
+  const queue = [{ dir: root, depth: 0 }];
+  while (queue.length > 0) {
+    const { dir, depth } = queue.shift();
+    try {
+      const manifest = JSON.parse(await readFile9(join11(dir, "package.json"), "utf8"));
+      if (manifest.name === packageName)
+        return dir;
+    } catch {
+    }
+    if (depth >= maxDepth)
+      continue;
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      if (entry.name === "node_modules" || entry.name.startsWith("."))
+        continue;
+      queue.push({ dir: join11(dir, entry.name), depth: depth + 1 });
+    }
+  }
+  return null;
+}
+
+// ../manifest/dist/mutator.js
+import { readFile as readFile10, writeFile as writeFile4, stat as stat8 } from "fs/promises";
+import { join as join12 } from "path";
+import { parse as parseToml3, stringify as stringifyToml2 } from "smol-toml";
 
 // ../manifest/dist/lockfile.js
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import { stat as stat5 } from "fs/promises";
-import { join as join9 } from "path";
-var execFileAsync3 = promisify3(execFile3);
-async function fileExists5(path) {
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { stat as stat9 } from "fs/promises";
+import { join as join13 } from "path";
+var execFileAsync5 = promisify5(execFile5);
+async function fileExists6(path) {
   try {
-    const s = await stat5(path);
+    const s = await stat9(path);
     return s.isFile();
   } catch {
     return false;
@@ -1404,7 +2480,7 @@ var PnpmLockfileAdapter = class {
   async regenerateLockfile(rootDirectory) {
     const start = Date.now();
     try {
-      const { stdout, stderr } = await execFileAsync3("pnpm", ["install", "--lockfile-only"], {
+      const { stdout, stderr } = await execFileAsync5("pnpm", ["install", "--lockfile-only"], {
         cwd: rootDirectory
       });
       return {
@@ -1426,7 +2502,29 @@ var NpmLockfileAdapter = class {
   async regenerateLockfile(rootDirectory) {
     const start = Date.now();
     try {
-      const { stdout, stderr } = await execFileAsync3("npm", ["install", "--package-lock-only"], {
+      const { stdout, stderr } = await execFileAsync5("npm", ["install", "--package-lock-only"], {
+        cwd: rootDirectory
+      });
+      return {
+        success: true,
+        output: (stdout + "\n" + stderr).trim(),
+        durationMs: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: err.message || String(err),
+        durationMs: Date.now() - start
+      };
+    }
+  }
+};
+var CargoLockfileAdapter = class {
+  packageManager = "cargo";
+  async regenerateLockfile(rootDirectory) {
+    const start = Date.now();
+    try {
+      const { stdout, stderr } = await execFileAsync5("cargo", ["generate-lockfile"], {
         cwd: rootDirectory
       });
       return {
@@ -1446,55 +2544,99 @@ var NpmLockfileAdapter = class {
 var AutoLockfileAdapter = class {
   packageManager = "npm";
   async regenerateLockfile(rootDirectory) {
-    if (await fileExists5(join9(rootDirectory, "pnpm-lock.yaml"))) {
+    const hasPnpm = await fileExists6(join13(rootDirectory, "pnpm-lock.yaml"));
+    const hasNpm = await fileExists6(join13(rootDirectory, "package-lock.json"));
+    const hasCargo = await fileExists6(join13(rootDirectory, "Cargo.toml")) || await fileExists6(join13(rootDirectory, "Cargo.lock"));
+    if (hasCargo && !hasPnpm && !hasNpm) {
+      this.packageManager = "cargo";
+      return new CargoLockfileAdapter().regenerateLockfile(rootDirectory);
+    }
+    if (hasPnpm) {
       this.packageManager = "pnpm";
-      return new PnpmLockfileAdapter().regenerateLockfile(rootDirectory);
+      const res = await new PnpmLockfileAdapter().regenerateLockfile(rootDirectory);
+      if (hasCargo) {
+        await new CargoLockfileAdapter().regenerateLockfile(rootDirectory).catch(() => {
+        });
+      }
+      return res;
     }
-    if (await fileExists5(join9(rootDirectory, "package-lock.json"))) {
+    if (hasNpm) {
       this.packageManager = "npm";
-      return new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
+      const res = await new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
+      if (hasCargo) {
+        await new CargoLockfileAdapter().regenerateLockfile(rootDirectory).catch(() => {
+        });
+      }
+      return res;
+    }
+    if (hasCargo) {
+      this.packageManager = "cargo";
+      return new CargoLockfileAdapter().regenerateLockfile(rootDirectory);
     }
     return new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
   }
 };
 
 // ../publisher-npm/dist/publisher.js
-import { execFile as execFile4, spawn as spawn2 } from "child_process";
-import { promisify as promisify4 } from "util";
-var execFileAsync4 = promisify4(execFile4);
+import { execFile as execFile6, spawn as spawn2 } from "child_process";
+import { promisify as promisify6 } from "util";
+import * as Effect2 from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as prompts from "@clack/prompts";
+import colors from "picocolors";
+var execFileAsync6 = promisify6(execFile6);
 function openBrowser(url) {
   const platform = process.platform;
   try {
     if (platform === "darwin") {
-      execFile4("open", [url]);
+      execFile6("open", [url]);
     } else if (platform === "win32") {
-      execFile4("cmd", ["/c", "start", '""', url]);
+      execFile6("cmd", ["/c", "start", '""', url]);
     } else {
-      execFile4("xdg-open", [url]);
+      execFile6("xdg-open", [url]);
     }
   } catch {
   }
 }
 async function pollForWebAuthToken(doneUrl, timeoutMs = 9e4) {
-  const start = Date.now();
-  const pollIntervalMs = 1500;
-  while (Date.now() - start < timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
     try {
-      const res = await fetch(doneUrl, {
+      const response = await fetch(doneUrl, {
         headers: { "user-agent": "verelease-npm-publisher" }
       });
-      if (res.status === 200) {
-        const json = await res.json();
-        if (json && json.token) {
-          return json.token;
-        }
+      if (response.status === 200) {
+        const body = await response.json();
+        if (body.token)
+          return body.token;
+      } else if (response.status !== 202) {
+        return null;
       }
+      const retryAfter = Number(response.headers.get("retry-after"));
+      await new Promise((resolve3) => setTimeout(resolve3, Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : 1500));
     } catch {
+      await new Promise((resolve3) => setTimeout(resolve3, 1500));
     }
-    await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
   }
   return null;
 }
+function getNpmLoginUrl(authUrl) {
+  const parsed = new URL(authUrl);
+  return `https://www.npmjs.com/login?next=${encodeURIComponent(parsed.pathname + parsed.search)}`;
+}
+function mergePublishedAndUnpublishedVersions(versions, time) {
+  const published = Array.isArray(versions) ? versions : typeof versions === "string" ? [versions] : [];
+  const ghosts = [];
+  if (time && typeof time === "object") {
+    for (const key of Object.keys(time)) {
+      if (key === "created" || key === "modified")
+        continue;
+      if (!published.includes(key))
+        ghosts.push(key);
+    }
+  }
+  return [...published, ...ghosts];
+}
 var NpmPublishProvider = class {
   options;
   name = "npm";
@@ -1507,20 +2649,90 @@ var NpmPublishProvider = class {
     }
     return channel;
   }
+  /**
+   * Check npm authentication status without throwing.
+   */
+  async checkAuth() {
+    try {
+      const { stdout } = await execFileAsync6("npm", ["whoami"]);
+      const username = stdout.trim();
+      return { authenticated: true, username };
+    } catch (err) {
+      return {
+        authenticated: false,
+        error: err.stderr || err.message || "401 Unauthorized"
+      };
+    }
+  }
+  /**
+   * Proactively verifies npm authentication.
+   * If unauthenticated and interactive, prompts the user to log in now,
+   * runs `npm login` interactively, verifies the login, and continues.
+   */
+  async ensureAuth(options = {}) {
+    const isInteractive = options.interactive ?? (this.options.interactive || !process.env.CI && process.stdin.isTTY);
+    const status = await this.checkAuth();
+    if (status.authenticated && status.username) {
+      return status.username;
+    }
+    if (!isInteractive) {
+      throw new NpmAuthError({
+        message: "You are not logged in to npm (npm whoami failed with 401). Run 'npm login' or configure NPM_TOKEN / NODE_AUTH_TOKEN in CI."
+      });
+    }
+    prompts.log.warn(colors.yellow("You are not currently logged in to npm."));
+    const shouldLogin = await prompts.confirm({
+      message: "Would you like to log in to npm now?",
+      initialValue: true
+    });
+    if (prompts.isCancel(shouldLogin) || !shouldLogin) {
+      throw new NpmAuthError({
+        message: "npm authentication cancelled. Run 'npm login' before releasing."
+      });
+    }
+    prompts.log.info(colors.cyan("Launching npm login in your terminal..."));
+    await new Promise((resolve3, reject) => {
+      const child = spawn2("npm", ["login"], { stdio: "inherit" });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve3();
+        } else {
+          reject(new NpmAuthError({
+            message: `npm login exited with code ${code}`,
+            code: code ?? void 0
+          }));
+        }
+      });
+      child.on("error", (err) => {
+        reject(new NpmAuthError({
+          message: `Failed to launch npm login: ${err.message}`
+        }));
+      });
+    });
+    const recheck = await this.checkAuth();
+    if (recheck.authenticated && recheck.username) {
+      prompts.log.success(colors.green(`Authenticated as ${colors.bold(recheck.username)} on npm.`));
+      return recheck.username;
+    }
+    throw new NpmAuthError({
+      message: "npm login completed, but npm authentication could not be verified."
+    });
+  }
   async prepare(ctx) {
     try {
-      await execFileAsync4("npm", ["pack", "--dry-run"], {
+      await execFileAsync6("npm", ["pack", "--dry-run"], {
         cwd: ctx.packagePlan.directory
       });
     } catch (err) {
-      throw new Error(`Failed packing verification for package ${ctx.packagePlan.name}: ${err.message || String(err)}`);
+      throw new PublishError({
+        packageName: ctx.packagePlan.name,
+        message: `Failed packing verification for package ${ctx.packagePlan.name}: ${err.message || String(err)}`
+      });
     }
-    if (!ctx.dryRun && !process.env.CI) {
-      try {
-        await execFileAsync4("npm", ["whoami"]);
-      } catch {
-        throw new Error(`You are not logged in to npm (npm whoami failed with 401). Please run 'npm login' first.`);
-      }
+    if (!ctx.dryRun) {
+      await this.ensureAuth({
+        interactive: this.options.interactive ?? (!process.env.CI && process.stdin.isTTY)
+      });
     }
   }
   async publish(ctx) {
@@ -1530,8 +2742,8 @@ var NpmPublishProvider = class {
     if (ctx.dryRun) {
       args.push("--dry-run");
     }
-    const access = ctx.access || this.options.defaultAccess || "public";
-    args.push("--access", access);
+    const access2 = ctx.access || this.options.defaultAccess || "public";
+    args.push("--access", access2);
     const hasOidc = !!(process.env.ACTIONS_ID_TOKEN_REQUEST_URL || process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN);
     const useProvenance = ctx.provenance ?? this.options.provenance ?? hasOidc;
     if (useProvenance) {
@@ -1545,8 +2757,7 @@ var NpmPublishProvider = class {
     }
     const isInteractive = this.options.interactive ?? (!ctx.dryRun && !process.env.CI && process.stdin.isTTY);
     if (isInteractive) {
-      console.log(`
-  \u{1F510} Interactive terminal detected for npm publish:`);
+      prompts.log.info(colors.cyan("Terminal ready for npm publish authentication:"));
       console.log(`     \u2022 WebAuthn / Passkey / Touch ID: press ENTER when prompted to open browser.`);
       console.log(`     \u2022 Authenticator App: enter your 6-digit TOTP code if prompted.
 `);
@@ -1596,87 +2807,338 @@ var NpmPublishProvider = class {
         });
       });
     }
-    try {
-      const { stdout, stderr } = await execFileAsync4("npm", args, {
-        cwd: ctx.packagePlan.directory
+    return new Promise((resolve3) => {
+      const child = spawn2("npm", args, {
+        cwd: ctx.packagePlan.directory,
+        stdio: ["ignore", "pipe", "pipe"]
       });
-      return {
-        provider: this.name,
-        packageName: ctx.packagePlan.name,
-        version: ctx.packagePlan.proposedVersion,
-        published: true,
-        dryRun: ctx.dryRun,
-        distTag,
-        durationMs: Date.now() - startTime,
-        output: (stdout + "\n" + stderr).trim()
-      };
-    } catch (err) {
-      const combinedOutput = `${err.stdout || ""}
-${err.stderr || ""}
-${err.message || ""}`;
-      const authUrlMatch = combinedOutput.match(/https:\/\/www\.npmjs\.com\/auth\/cli\/[^\s\x1b"']+/);
-      const doneUrlMatch = combinedOutput.match(/https:\/\/registry\.npmjs\.org\/-\/v1\/done\?authId=[^\s\x1b"']+/);
-      if (authUrlMatch && doneUrlMatch && !ctx.dryRun) {
-        const authUrl = authUrlMatch[0];
-        const doneUrl = doneUrlMatch[0];
-        console.log(`
-\x1B[36m\u{1F511} WebAuthn / Security Key 2FA Detected!\x1B[0m`);
-        console.log(`   Your npm account uses Touch ID / security key (WebAuthn) instead of a 6-digit code.`);
-        console.log(`   Opening browser to authenticate:`);
-        console.log(`   \u{1F449} \x1B[4m${authUrl}\x1B[0m
-`);
-        openBrowser(authUrl);
-        console.log(`\u23F3 Waiting for Touch ID / security key approval in your browser (up to 90s)...`);
-        const token = await pollForWebAuthToken(doneUrl, 9e4);
-        if (token) {
-          console.log(`\x1B[32m\u2713 Touch ID / Passkey approved! Completing publish...\x1B[0m
-`);
-          return this.publish({
-            ...ctx,
-            extraArgs: [...ctx.extraArgs || [], "--otp", token]
-          });
-        } else {
-          console.error(`\x1B[31m\u274C WebAuthn approval timed out or was cancelled.\x1B[0m
+      let stdout = "";
+      let stderr = "";
+      let openedAuthUrl = false;
+      let authUrl;
+      let doneUrl;
+      const handleOutput = (chunk, isError) => {
+        const text = chunk.toString();
+        if (isError)
+          stderr += text;
+        else
+          stdout += text;
+        const doneUrlMatch = `${stdout}
+${stderr}`.match(/https:\/\/registry\.npmjs\.org\/-\/v1\/done\?authId=[^\s\x1b"']+/);
+        doneUrl ??= doneUrlMatch?.[0];
+        if (!openedAuthUrl && !ctx.dryRun) {
+          const authUrlMatch = `${stdout}
+${stderr}`.match(/https:\/\/www\.npmjs\.com\/auth\/cli\/[^\s\x1b"']+/);
+          if (authUrlMatch) {
+            openedAuthUrl = true;
+            authUrl = authUrlMatch[0];
+            const loginUrl = getNpmLoginUrl(authUrl);
+            prompts.log.info(colors.cyan(colors.bold("\u{1F511} WebAuthn / Security Key 2FA Detected!")));
+            console.log("   Opening npm's authentication page while publish is waiting:");
+            console.log(`   \u{1F449} ${colors.underline(loginUrl)}
 `);
+            openBrowser(loginUrl);
+          }
         }
-      }
-      return {
-        provider: this.name,
-        packageName: ctx.packagePlan.name,
-        version: ctx.packagePlan.proposedVersion,
-        published: false,
-        dryRun: ctx.dryRun,
-        distTag,
-        durationMs: Date.now() - startTime,
-        output: err.stdout || "",
-        error: err.message || String(err)
       };
-    }
+      child.stdout?.on("data", (chunk) => handleOutput(chunk, false));
+      child.stderr?.on("data", (chunk) => handleOutput(chunk, true));
+      child.on("error", (error) => {
+        resolve3({
+          provider: this.name,
+          packageName: ctx.packagePlan.name,
+          version: ctx.packagePlan.proposedVersion,
+          published: false,
+          dryRun: ctx.dryRun,
+          distTag,
+          durationMs: Date.now() - startTime,
+          output: `${stdout}
+${stderr}`.trim(),
+          error: error.message
+        });
+      });
+      child.on("close", async (code) => {
+        if (code !== 0 && doneUrl && !ctx.dryRun) {
+          const token = await pollForWebAuthToken(doneUrl);
+          if (token) {
+            resolve3(await this.publish({
+              ...ctx,
+              extraArgs: [...ctx.extraArgs || [], "--otp", token]
+            }));
+            return;
+          }
+        }
+        const output = `${stdout}
+${stderr}`.trim();
+        resolve3({
+          provider: this.name,
+          packageName: ctx.packagePlan.name,
+          version: ctx.packagePlan.proposedVersion,
+          published: code === 0,
+          dryRun: ctx.dryRun,
+          distTag,
+          durationMs: Date.now() - startTime,
+          output,
+          error: code === 0 ? void 0 : `npm publish exited with code ${code}.`
+        });
+      });
+    });
   }
+  /**
+   * Resiliently fetches published versions using EffectTS retry schedule.
+   *
+   * The result also includes versions that were previously published and
+   * then unpublished. npm permanently blocks republishing an unpublished
+   * `name@version` (a supply-chain safeguard introduced after the left-pad
+   * incident), so those "ghost" versions must be treated as unavailable
+   * just like currently-published ones when proposing the next version.
+   */
   async getPublishedVersions(packageName) {
+    const fetchVersions = Effect2.tryPromise({
+      try: async () => {
+        const { stdout } = await execFileAsync6("npm", ["view", packageName, "--json", "versions", "time"]);
+        const parsed = JSON.parse(stdout.trim());
+        return mergePublishedAndUnpublishedVersions(parsed.versions, parsed.time);
+      },
+      catch: (err) => err
+    });
+    const withRetry = Effect2.retry(fetchVersions, {
+      schedule: Schedule.recurs(2)
+    });
     try {
-      const { stdout } = await execFileAsync4("npm", ["view", packageName, "versions", "--json"]);
-      const parsed = JSON.parse(stdout.trim());
-      if (Array.isArray(parsed)) {
-        return parsed;
-      }
-      if (typeof parsed === "string") {
-        return [parsed];
-      }
-      return [];
+      return await Effect2.runPromise(withRetry);
     } catch {
       return [];
     }
   }
 };
 
+// ../publisher-cargo/dist/publisher.js
+import { execFile as execFile7, spawn as spawn3 } from "child_process";
+import { promisify as promisify7 } from "util";
+import { readFile as readFile11, stat as stat10 } from "fs/promises";
+import { join as join14 } from "path";
+import { homedir } from "os";
+import * as Effect3 from "effect/Effect";
+import * as Schedule2 from "effect/Schedule";
+import * as prompts2 from "@clack/prompts";
+import colors2 from "picocolors";
+import { parse as parseToml4 } from "smol-toml";
+var execFileAsync7 = promisify7(execFile7);
+async function fileExists7(path) {
+  try {
+    const s = await stat10(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+var CargoPublishProvider = class {
+  options;
+  name = "cargo";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Checks whether crates.io / cargo credentials exist.
+   * Looks in CARGO_REGISTRY_TOKEN env var, options.token,
+   * ~/.cargo/credentials.toml, or ~/.cargo/credentials.
+   */
+  async checkAuth() {
+    if (this.options.token) {
+      return { authenticated: true, token: this.options.token };
+    }
+    if (process.env.CARGO_REGISTRY_TOKEN) {
+      return { authenticated: true, token: process.env.CARGO_REGISTRY_TOKEN };
+    }
+    const home = homedir();
+    const credToml = join14(home, ".cargo", "credentials.toml");
+    const credOld = join14(home, ".cargo", "credentials");
+    for (const credPath of [credToml, credOld]) {
+      if (await fileExists7(credPath)) {
+        try {
+          const content = await readFile11(credPath, "utf8");
+          const parsed = parseToml4(content);
+          const token = parsed.registry?.token || parsed.registries?.["crates-io"]?.token;
+          if (token) {
+            return { authenticated: true, token };
+          }
+        } catch {
+        }
+      }
+    }
+    return {
+      authenticated: false,
+      error: "No Cargo token found in environment (CARGO_REGISTRY_TOKEN) or ~/.cargo/credentials.toml"
+    };
+  }
+  /**
+   * Ensures auth is present. If interactive and missing, prompts the user to enter a token.
+   */
+  async ensureAuth(options = {}) {
+    const isInteractive = options.interactive !== void 0 ? options.interactive : this.options.interactive !== false && Boolean(process.stdout.isTTY);
+    const status = await this.checkAuth();
+    if (status.authenticated && status.token) {
+      return status.token;
+    }
+    if (!isInteractive) {
+      throw new CargoAuthError({
+        message: status.error || "Missing crates.io token in non-interactive mode"
+      });
+    }
+    prompts2.note(`Crates.io authentication is required to publish Rust crates.
+Generate an API token at: ${colors2.cyan("https://crates.io/settings/tokens")}`, colors2.yellow("crates.io Token Required"));
+    const enteredToken = await prompts2.password({
+      message: "Paste your crates.io API token:",
+      validate(val) {
+        if (!val || val.trim().length === 0)
+          return "Token cannot be empty.";
+      }
+    });
+    if (prompts2.isCancel(enteredToken)) {
+      throw new CargoAuthError({
+        message: "Crates.io authentication cancelled by user."
+      });
+    }
+    const token = String(enteredToken).trim();
+    process.env.CARGO_REGISTRY_TOKEN = token;
+    return token;
+  }
+  /**
+   * Queries crates.io API for crate existence and released versions.
+   */
+  async queryCratesIo(crateName) {
+    const runQuery = Effect3.tryPromise({
+      try: async () => {
+        const url = `https://crates.io/api/v1/crates/${encodeURIComponent(crateName)}`;
+        const res = await fetch(url, {
+          headers: {
+            "User-Agent": "verelease-cargo-publisher (https://github.com/ivanjeremic/verelease)"
+          }
+        });
+        if (res.status === 404) {
+          return { exists: false, versions: [] };
+        }
+        if (!res.ok) {
+          throw new Error(`crates.io API error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        const versions = data.versions?.map((v) => v.num) || [];
+        return {
+          exists: true,
+          maxVersion: data.crate?.max_version,
+          versions
+        };
+      },
+      catch: (err) => err
+    });
+    const withRetry = Effect3.retry(runQuery, {
+      schedule: Schedule2.recurs(3)
+    });
+    return Effect3.runPromise(withRetry);
+  }
+  async prepare(ctx) {
+    if (!ctx.dryRun) {
+      await this.ensureAuth({ interactive: this.options.interactive });
+    }
+  }
+  async publish(ctx) {
+    const { packagePlan, dryRun } = ctx;
+    const startTime = Date.now();
+    const cargoBin = this.options.cargoBinary || "cargo";
+    let token;
+    if (!dryRun) {
+      token = await this.ensureAuth({ interactive: this.options.interactive });
+    }
+    const args = ["publish"];
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (this.options.registry) {
+      args.push("--registry", this.options.registry);
+    }
+    if (this.options.allowDirty ?? true) {
+      args.push("--allow-dirty");
+    }
+    if (ctx.extraArgs) {
+      args.push(...ctx.extraArgs);
+    }
+    return new Promise((resolve3, reject) => {
+      const child = spawn3(cargoBin, args, {
+        cwd: packagePlan.directory,
+        env: {
+          ...process.env,
+          ...token ? { CARGO_REGISTRY_TOKEN: token } : {}
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const combinedOutput = (stdout + "\n" + stderr).trim();
+        if (code !== 0) {
+          const errMsg = `cargo publish exited with code ${code}:
+${combinedOutput}`;
+          const pubErr = new PublishError({
+            message: errMsg,
+            packageName: packagePlan.name,
+            code: code ?? 1
+          });
+          return resolve3({
+            provider: this.name,
+            packageName: packagePlan.name,
+            version: packagePlan.proposedVersion,
+            published: false,
+            dryRun,
+            distTag: "latest",
+            durationMs,
+            output: combinedOutput,
+            error: errMsg
+          });
+        }
+        resolve3({
+          provider: this.name,
+          packageName: packagePlan.name,
+          version: packagePlan.proposedVersion,
+          published: !dryRun,
+          dryRun,
+          distTag: "latest",
+          durationMs,
+          output: combinedOutput
+        });
+      });
+      child.on("error", (err) => {
+        const durationMs = Date.now() - startTime;
+        resolve3({
+          provider: this.name,
+          packageName: packagePlan.name,
+          version: packagePlan.proposedVersion,
+          published: false,
+          dryRun,
+          distTag: "latest",
+          durationMs,
+          output: "",
+          error: `Failed to execute ${cargoBin}: ${err.message}`
+        });
+      });
+    });
+  }
+};
+
 // ../config/dist/config.js
-import { stat as stat6 } from "fs/promises";
-import { join as join10 } from "path";
+import { stat as stat11 } from "fs/promises";
+import { join as join15 } from "path";
 import { pathToFileURL } from "url";
-async function fileExists6(path) {
+async function fileExists8(path) {
   try {
-    const s = await stat6(path);
+    const s = await stat11(path);
     return s.isFile();
   } catch {
     return false;
@@ -1694,8 +3156,8 @@ async function loadConfig(rootDir) {
     "autoversion.config.mjs"
   ];
   for (const name of candidateNames) {
-    const fullPath = join10(rootDir, name);
-    if (await fileExists6(fullPath)) {
+    const fullPath = join15(rootDir, name);
+    if (await fileExists8(fullPath)) {
       try {
         const fileUrl = pathToFileURL(fullPath).href;
         const mod = await import(fileUrl);
@@ -1740,8 +3202,8 @@ var MigrationScriptSchema = z.object({
 });
 
 // ../ai/dist/changelog.js
-function renderChangelogMarkdown(version, date, data) {
-  const parts = [`# ${version} (${date})`, ""];
+function renderChangelogMarkdown(version2, date, data) {
+  const parts = [`# ${version2} (${date})`, ""];
   if (data.breakingChanges.length > 0) {
     parts.push("## \u26A0\uFE0F Breaking Changes");
     for (const item of data.breakingChanges) {
@@ -1949,13 +3411,13 @@ walkAndTransform(targetDir);
 }
 
 // ../ai/dist/validation.js
-import { cp, mkdtemp as mkdtemp4, rm as rm3, writeFile as writeFile4, mkdir as mkdir5, symlink as symlink2, readdir as readdir3 } from "fs/promises";
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-import { join as join11 } from "path";
-import { tmpdir as tmpdir4 } from "os";
+import { cp as cp2, mkdtemp as mkdtemp5, rm as rm4, writeFile as writeFile5, mkdir as mkdir5, symlink as symlink2, readdir as readdir4 } from "fs/promises";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
+import { join as join16 } from "path";
+import { tmpdir as tmpdir5 } from "os";
 import * as tar3 from "tar";
-var execFileAsync5 = promisify5(execFile5);
+var execFileAsync8 = promisify8(execFile8);
 
 // ../ai/dist/provider.js
 var TanStackReleaseAI = class {
@@ -2013,9 +3475,9 @@ ${JSON.stringify(input.breakingChanges, null, 2)}`;
 };
 
 // ../git/dist/git.js
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
-var execFileAsync6 = promisify6(execFile6);
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify9 } from "util";
+var execFileAsync9 = promisify9(execFile9);
 var GitManager = class {
   cwd;
   constructor(cwd = process.cwd()) {
@@ -2030,35 +3492,86 @@ var GitManager = class {
     }
     return `${options.packageName}@${options.version}`;
   }
+  /**
+   * The most recent release tag for a package, or null if it has never been
+   * released.
+   *
+   * Tags are matched by the same formats `formatTagName` writes, so this finds
+   * what a previous release actually created rather than assuming a convention.
+   */
+  async lastReleaseTag(packageName, strategy) {
+    const pattern = strategy === "fixed" ? "v*" : `${packageName}@*`;
+    try {
+      const { stdout } = await execFileAsync9("git", ["tag", "--list", pattern, "--sort=-creatordate"], { cwd: this.cwd });
+      const [first] = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+      return first ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Files under `directory` that changed between `ref` and the working tree.
+   *
+   * Used to answer whether a package changed at all since its last release. A
+   * package nobody touched should not be republished, and asking git is exact
+   * — far better evidence than inferring activity from a green test suite.
+   */
+  async changedFilesSince(ref, directory) {
+    try {
+      const { stdout } = await execFileAsync9("git", ["diff", "--name-only", `${ref}...HEAD`, "--", directory], { cwd: this.cwd });
+      const committed = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+      const { stdout: dirty } = await execFileAsync9("git", ["status", "--porcelain", "--", directory], { cwd: this.cwd });
+      const uncommitted = dirty.split("\n").map((line) => line.slice(3).trim()).filter(Boolean);
+      return [.../* @__PURE__ */ new Set([...committed, ...uncommitted])];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * The newest release tag in the repository, whatever package it names.
+   *
+   * A monorepo that tags only its root package still has a meaningful "last
+   * release" for everything released alongside it; without this, packages that
+   * are never tagged individually would have no reference point at all.
+   */
+  async latestReleaseTag() {
+    try {
+      const { stdout } = await execFileAsync9("git", ["tag", "--list", "--sort=-creatordate"], { cwd: this.cwd });
+      const [first] = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+      return first ?? null;
+    } catch {
+      return null;
+    }
+  }
   async isClean() {
-    const { stdout } = await execFileAsync6("git", ["status", "--porcelain"], {
+    const { stdout } = await execFileAsync9("git", ["status", "--porcelain"], {
       cwd: this.cwd
     });
     return stdout.trim().length === 0;
   }
   async getHeadCommit() {
-    const { stdout } = await execFileAsync6("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await execFileAsync9("git", ["rev-parse", "HEAD"], {
       cwd: this.cwd
     });
     return stdout.trim();
   }
   async createTag(tagName, message) {
     const args = ["tag", "-a", tagName, "-m", message || `Release ${tagName}`];
-    await execFileAsync6("git", args, { cwd: this.cwd });
+    await execFileAsync9("git", args, { cwd: this.cwd });
   }
   async createReleaseCommit(files, message = "chore(release): publish") {
     if (files.length > 0) {
-      await execFileAsync6("git", ["add", ...files], { cwd: this.cwd });
+      await execFileAsync9("git", ["add", ...files], { cwd: this.cwd });
     } else {
-      await execFileAsync6("git", ["add", "-A"], { cwd: this.cwd });
+      await execFileAsync9("git", ["add", "-A"], { cwd: this.cwd });
     }
-    await execFileAsync6("git", ["commit", "-m", message], { cwd: this.cwd });
+    await execFileAsync9("git", ["commit", "-m", message], { cwd: this.cwd });
     return this.getHeadCommit();
   }
 };
 
 // ../test-adapter/dist/command.js
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 var CommandTestAdapter = class {
   config;
   name = "command";
@@ -2083,7 +3596,7 @@ var CommandTestAdapter = class {
     const [executable, ...args] = cmd;
     const finalArgs = [...args, ...ctx.extraArgs || []];
     return new Promise((resolve3) => {
-      const child = spawn3(executable, finalArgs, {
+      const child = spawn4(executable, finalArgs, {
         cwd: ctx.packagePath,
         env: { ...process.env, ...ctx.env },
         stdio: ["ignore", "pipe", "pipe"]
@@ -2154,7 +3667,173 @@ var CommandTestAdapter = class {
               stack: err.stack
             }
           ],
-          totalTests: 1,
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+};
+
+// ../test-adapter/dist/cargo.js
+import { spawn as spawn5 } from "child_process";
+function parseCargoTestOutput(stdout, stderr) {
+  const tests = [];
+  const lines = stdout.split("\n");
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  const testLineRegex = /^\s*test\s+([^\s]+)\s+\.\.\.\s+(ok|FAILED|ignored)/;
+  const failureSection = [];
+  let inFailureSection = false;
+  for (const line of lines) {
+    if (line.startsWith("failures:")) {
+      inFailureSection = true;
+      continue;
+    }
+    if (inFailureSection) {
+      if (line.startsWith("test result:")) {
+        inFailureSection = false;
+      } else if (line.trim()) {
+        failureSection.push(line);
+      }
+    }
+    const match = line.match(testLineRegex);
+    if (match) {
+      const [, testName, statusStr] = match;
+      if (statusStr === "ok") {
+        passed++;
+        tests.push({
+          name: testName,
+          status: "passed"
+        });
+      } else if (statusStr === "FAILED") {
+        failed++;
+        tests.push({
+          name: testName,
+          status: "failed",
+          failure: {
+            message: `Cargo test assertion failed: ${testName}`
+          }
+        });
+      } else if (statusStr === "ignored") {
+        skipped++;
+        tests.push({
+          name: testName,
+          status: "skipped"
+        });
+      }
+    }
+  }
+  const summaryRegex = /test result:\s+(ok|FAILED)\.\s+(\d+)\s+passed;\s+(\d+)\s+failed;\s+(\d+)\s+ignored/;
+  const summaryMatch = stdout.match(summaryRegex);
+  if (summaryMatch) {
+    const [, resultStr, pStr, fStr, iStr] = summaryMatch;
+    passed = parseInt(pStr, 10);
+    failed = parseInt(fStr, 10);
+    skipped = parseInt(iStr, 10);
+  }
+  const total = passed + failed + skipped;
+  const success = failed === 0;
+  return {
+    success,
+    totalTests: total,
+    passedTests: passed,
+    failedTests: failed,
+    skippedTests: skipped,
+    tests,
+    failures: failureSection
+  };
+}
+var CargoTestAdapter = class {
+  options;
+  name = "cargo:test";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async detect(ctx) {
+    const isCargo = ctx.files.includes("Cargo.toml") || Boolean(ctx.manifest && ("package" in ctx.manifest || "workspace" in ctx.manifest));
+    if (isCargo) {
+      return {
+        supported: true,
+        confidence: 0.95,
+        suggestedConfig: { command: ["cargo", "test"] }
+      };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const cargoBin = this.options.cargoBinary || "cargo";
+    const baseArgs = ["test", ...this.options.extraArgs || []];
+    const finalArgs = [...baseArgs, ...ctx.extraArgs || []];
+    return new Promise((resolve3) => {
+      const child = spawn5(cargoBin, finalArgs, {
+        cwd: ctx.packagePath,
+        env: { ...process.env, ...ctx.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const parsed = parseCargoTestOutput(stdout, stderr);
+        const suites = [
+          {
+            name: "cargo-test-suite",
+            status: parsed.success && code === 0 ? "passed" : "failed",
+            durationMs,
+            tests: parsed.tests
+          }
+        ];
+        const diagnostics = [];
+        if (code !== 0 || !parsed.success) {
+          diagnostics.push({
+            severity: "error",
+            message: parsed.failures.join("\n") || stderr.trim() || `cargo test exited with code ${code}`
+          });
+        }
+        resolve3({
+          adapter: this.name,
+          runtime: "rust",
+          command: [cargoBin, ...finalArgs],
+          startedAt,
+          durationMs,
+          success: code === 0 && parsed.success,
+          suites,
+          diagnostics,
+          totalTests: parsed.totalTests,
+          passedTests: parsed.passedTests,
+          failedTests: parsed.failedTests,
+          skippedTests: parsed.skippedTests
+        });
+      });
+      child.on("error", (err) => {
+        const durationMs = Date.now() - startTime;
+        resolve3({
+          adapter: this.name,
+          runtime: "rust",
+          command: [cargoBin, ...finalArgs],
+          startedAt,
+          durationMs,
+          success: false,
+          suites: [],
+          diagnostics: [
+            {
+              severity: "error",
+              message: `Failed to spawn ${cargoBin}: ${err.message}`
+            }
+          ],
+          totalTests: 0,
           passedTests: 0,
           failedTests: 1,
           skippedTests: 0
@@ -2165,8 +3844,9 @@ var CommandTestAdapter = class {
 };
 
 // ../test-adapter/dist/test-suite-analyzer.js
-import { readFile as readFile6, readdir as readdir4 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile12, readdir as readdir5 } from "fs/promises";
+import { join as join17 } from "path";
+import { parse as parseToml5 } from "smol-toml";
 var TestSuiteAnalyzer = class {
   name = "test-suite-analyzer";
   adapters;
@@ -2174,6 +3854,7 @@ var TestSuiteAnalyzer = class {
   constructor(options) {
     this.adapters = [
       ...options?.adapters ?? [],
+      new CargoTestAdapter(),
       new CommandTestAdapter()
       // always available as lowest-confidence fallback
     ];
@@ -2181,24 +3862,27 @@ var TestSuiteAnalyzer = class {
   }
   async analyze(context) {
     const { packageName, packagePath } = context;
-    let manifest;
+    let manifest = {};
+    let isCargo = false;
     try {
-      const raw = await readFile6(join12(packagePath, "package.json"), "utf8");
+      const raw = await readFile12(join17(packagePath, "package.json"), "utf8");
       manifest = JSON.parse(raw);
     } catch {
-      return [];
-    }
-    const scripts = manifest.scripts || {};
-    if (!scripts.test) {
-      return [];
+      try {
+        const cargoRaw = await readFile12(join17(packagePath, "Cargo.toml"), "utf8");
+        manifest = parseToml5(cargoRaw);
+        isCargo = true;
+      } catch {
+        return [];
+      }
     }
-    let files;
-    try {
-      const entries = await readdir4(packagePath, { recursive: true });
-      files = entries.map(String);
-    } catch {
-      files = [];
+    if (!isCargo) {
+      const scripts = manifest.scripts || {};
+      if (!scripts.test) {
+        return [];
+      }
     }
+    const files = await listProjectFiles(packagePath);
     const detectionCtx = { packagePath, manifest, files };
     const best = await this.detectBestAdapter(detectionCtx);
     if (!best) {
@@ -2215,6 +3899,7 @@ var TestSuiteAnalyzer = class {
       return [
         {
           id: `test.suite.error:${packageName}`,
+          blocking: true,
           package: packageName,
           source: "test",
           severity: "major",
@@ -2247,25 +3932,7 @@ var TestSuiteAnalyzer = class {
       return [];
     }
     if (testRun.success) {
-      return [
-        {
-          id: `test.suite.pass:${packageName}`,
-          package: packageName,
-          source: "test",
-          severity: "patch",
-          confidence: 0.9,
-          title: `Test suite passed (${testRun.passedTests}/${testRun.totalTests} tests)`,
-          description: `All ${testRun.totalTests} tests passed via ${adapterName} in ${testRun.durationMs}ms. Code changes are confirmed compatible.`,
-          metadata: {
-            adapter: adapterName,
-            total: testRun.totalTests,
-            passed: testRun.passedTests,
-            failed: testRun.failedTests,
-            skipped: testRun.skippedTests,
-            durationMs: testRun.durationMs
-          }
-        }
-      ];
+      return [];
     }
     const failedSuites = testRun.suites.filter((s) => s.status === "failed");
     const failedTests = failedSuites.flatMap((s) => s.tests.filter((t) => t.status === "failed"));
@@ -2276,6 +3943,7 @@ var TestSuiteAnalyzer = class {
         package: packageName,
         source: "test",
         severity: "major",
+        blocking: true,
         confidence: 0.85,
         title: `Test suite failed (${testRun.failedTests}/${testRun.totalTests} tests failed)`,
         description: `${testRun.failedTests} tests failed via ${adapterName}:
@@ -2292,9 +3960,53 @@ ${failureMessages}`,
     ];
   }
 };
+var UNINTERESTING_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  "target",
+  "tmp",
+  "test-results",
+  "playwright-report"
+]);
+async function listProjectFiles(root, { maxDepth = 3, maxEntries = 5e3 } = {}) {
+  const files = [];
+  const queue = [
+    { dir: root, depth: 0, prefix: "" }
+  ];
+  while (queue.length > 0 && files.length < maxEntries) {
+    const { dir, depth, prefix } = queue.shift();
+    let entries;
+    try {
+      entries = await readdir5(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxEntries)
+        break;
+      const relative3 = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (UNINTERESTING_DIRECTORIES.has(entry.name) || entry.name.startsWith("."))
+          continue;
+        if (depth < maxDepth) {
+          queue.push({ dir: join17(dir, entry.name), depth: depth + 1, prefix: relative3 });
+        }
+      } else {
+        files.push(relative3);
+      }
+    }
+  }
+  return files;
+}
 
 // ../test-adapter-vitest/dist/vitest.js
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn6 } from "child_process";
+import { mkdtemp as mkdtemp6, readFile as readFile13, rm as rm5 } from "fs/promises";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join18 } from "path";
 var VitestTestAdapter = class {
   name = "vitest";
   async detect(ctx) {
@@ -2315,9 +4027,20 @@ var VitestTestAdapter = class {
   async run(ctx) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = Date.now();
-    const command = ["npx", "vitest", "run", "--reporter=json", ...ctx.testFiles || []];
+    const reportDirectory = await mkdtemp6(join18(tmpdir6(), "verelease-vitest-"));
+    const reportFile = join18(reportDirectory, "report.json");
+    const declaredArgs = await readVitestScriptArgs(ctx.packagePath);
+    const command = [
+      "npx",
+      "vitest",
+      "run",
+      "--reporter=json",
+      `--outputFile=${reportFile}`,
+      ...declaredArgs,
+      ...ctx.testFiles || []
+    ];
     return new Promise((resolve3) => {
-      const child = spawn4(command[0], command.slice(1), {
+      const child = spawn6(command[0], command.slice(1), {
         cwd: ctx.packagePath,
         env: {
           ...process.env,
@@ -2334,12 +4057,19 @@ var VitestTestAdapter = class {
       child.stderr?.on("data", (chunk) => {
         stderr += chunk.toString();
       });
-      child.on("close", (code) => {
+      child.on("close", async (code) => {
         const durationMs = Date.now() - startTime;
-        const normalized = this.parseJsonOutput(stdout, stderr, code === 0, durationMs, startedAt, command);
-        resolve3(normalized);
+        let jsonOutput = stdout;
+        try {
+          jsonOutput = await readFile13(reportFile, "utf8");
+        } catch {
+        } finally {
+          await rm5(reportDirectory, { recursive: true, force: true }).catch(() => void 0);
+        }
+        resolve3(this.parseJsonOutput(jsonOutput, stderr, code === 0, durationMs, startedAt, command));
       });
       child.on("error", (err) => {
+        void rm5(reportDirectory, { recursive: true, force: true });
         resolve3({
           adapter: this.name,
           runtime: process.version,
@@ -2432,9 +4162,74 @@ var VitestTestAdapter = class {
     };
   }
 };
+async function readVitestScriptArgs(packagePath) {
+  let script = "";
+  try {
+    const { readFile: readFile16 } = await import("fs/promises");
+    const { join: join21 } = await import("path");
+    const manifest = JSON.parse(await readFile16(join21(packagePath, "package.json"), "utf8"));
+    script = manifest.scripts?.test ?? "";
+  } catch {
+    return [];
+  }
+  if (!script.includes("vitest"))
+    return [];
+  const tokens = tokenizeCommand(script);
+  const start = tokens.indexOf("vitest");
+  if (start === -1)
+    return [];
+  const args = [];
+  for (let index = start + 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "run")
+      continue;
+    if (token.startsWith("--reporter")) {
+      if (!token.includes("="))
+        index += 1;
+      continue;
+    }
+    if (token.startsWith("--outputFile")) {
+      if (!token.includes("="))
+        index += 1;
+      continue;
+    }
+    if (token === "&&" || token === ";")
+      break;
+    args.push(token);
+  }
+  return args;
+}
+function tokenizeCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const character of command) {
+    if (quote) {
+      if (character === quote)
+        quote = null;
+      else
+        current += character;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (/\s/u.test(character)) {
+      if (current)
+        tokens.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current)
+    tokens.push(current);
+  return tokens;
+}
 
 // ../test-adapter-jest/dist/jest.js
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 var JestTestAdapter = class {
   name = "jest";
   async detect(ctx) {
@@ -2458,7 +4253,7 @@ var JestTestAdapter = class {
     const startTime = Date.now();
     const command = ["npx", "jest", "--json", ...ctx.testFiles || []];
     return new Promise((resolve3) => {
-      const child = spawn5(command[0], command.slice(1), {
+      const child = spawn7(command[0], command.slice(1), {
         cwd: ctx.packagePath,
         env: {
           ...process.env,
@@ -2574,7 +4369,7 @@ var JestTestAdapter = class {
 };
 
 // ../test-adapter-bun/dist/bun.js
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 var BunTestAdapter = class {
   name = "bun:test";
   async detect(ctx) {
@@ -2591,7 +4386,7 @@ var BunTestAdapter = class {
     const startTime = Date.now();
     const command = ["bun", "test", ...ctx.testFiles || []];
     return new Promise((resolve3) => {
-      const child = spawn6(command[0], command.slice(1), {
+      const child = spawn8(command[0], command.slice(1), {
         cwd: ctx.packagePath,
         env: {
           ...process.env,
@@ -2679,7 +4474,7 @@ var BunTestAdapter = class {
 };
 
 // ../test-adapter-deno/dist/deno.js
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 var DenoTestAdapter = class {
   name = "deno:test";
   async detect(ctx) {
@@ -2696,7 +4491,7 @@ var DenoTestAdapter = class {
     const startTime = Date.now();
     const command = ["deno", "test", "--allow-all", ...ctx.testFiles || []];
     return new Promise((resolve3) => {
-      const child = spawn7(command[0], command.slice(1), {
+      const child = spawn9(command[0], command.slice(1), {
         cwd: ctx.packagePath,
         env: {
           ...process.env,
@@ -2784,18 +4579,29 @@ var DenoTestAdapter = class {
 
 // src/cli.ts
 import semver4 from "semver";
-async function promptConfirm(question, defaultYes = false) {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  try {
-    const answer = (await rl.question(question)).trim().toLowerCase();
-    if (!answer) return defaultYes;
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
+var RELEASE_CHANNELS = /* @__PURE__ */ new Set(["stable", "alpha", "beta", "rc", "canary"]);
+function resolveReleaseChannel(requestedChannel, configuredChannel, packageVersions) {
+  const explicitChannel = requestedChannel || configuredChannel;
+  if (explicitChannel) {
+    if (!RELEASE_CHANNELS.has(explicitChannel)) {
+      throw new Error(
+        `Unsupported release channel "${explicitChannel}". Choose stable, alpha, beta, rc, or canary.`
+      );
+    }
+    return explicitChannel;
+  }
+  const prereleaseChannels = new Set(
+    packageVersions.map((version2) => semver4.parse(version2)?.prerelease[0]).filter((channel) => typeof channel === "string")
+  );
+  if (prereleaseChannels.size === 1) {
+    return [...prereleaseChannels][0];
+  }
+  if (prereleaseChannels.size > 1) {
+    throw new Error(
+      `Packages are on multiple prerelease channels (${[...prereleaseChannels].join(", ")}). Choose an explicit channel with --channel.`
+    );
   }
+  return "stable";
 }
 var VereleaseCli = class {
   cwd;
@@ -2803,15 +4609,30 @@ var VereleaseCli = class {
     this.cwd = resolve2(options.cwd || process.cwd());
   }
   async createPlan(options = {}) {
+    const isInteractive = process.stdout.isTTY && !options.json;
+    const spin = isInteractive ? prompts3.spinner() : void 0;
+    spin?.start("Resolving workspace package graph");
     const config = await loadConfig(this.cwd);
     const resolver = new DefaultWorkspaceResolver();
     const discovery = await resolver.resolve(this.cwd);
+    const channel = resolveReleaseChannel(
+      options.channel,
+      config.versioning?.channel,
+      discovery.packages.map((pkg) => pkg.version)
+    );
+    spin?.stop(`Discovered ${colors3.bold(discovery.packages.length)} workspace package${discovery.packages.length === 1 ? "" : "s"}`);
+    for (const skippedPackage of discovery.skipped ?? []) {
+      console.log(
+        `${colors3.dim("skipped")} ${skippedPackage.name ?? skippedPackage.directory}: ${skippedPackage.reason}`
+      );
+    }
     const contractStore = new FileContractStore(
-      join13(this.cwd, config.contracts?.directory || ".verelease/contracts")
+      join19(this.cwd, config.contracts?.directory || ".verelease/contracts")
     );
     const contractAnalyzer = new ContractCompatibilityAnalyzer(contractStore);
     const apiDiffAnalyzer = new ApiDiffAnalyzer();
     const baselineFetcher = new BaselineFetcher();
+    const gitBaselineResolver = new GitBaselineResolver(this.cwd);
     const testSuiteAnalyzer = config.tests?.skip ? null : new TestSuiteAnalyzer({
       adapters: [
         new VitestTestAdapter(),
@@ -2824,12 +4645,32 @@ var VereleaseCli = class {
     });
     const semverEngine = new DefaultSemVerDecisionEngine();
     const npmPublisher = new NpmPublishProvider();
+    const cargoPublisher = new CargoPublishProvider();
+    const cargoSemVerAnalyzer = new CargoSemVerAnalyzer();
     const evidenceMap = /* @__PURE__ */ new Map();
+    const comparedAgainst = /* @__PURE__ */ new Map();
     const initialBumps = /* @__PURE__ */ new Map();
-    const baselineTmpDir = await mkdtemp5(join13(tmpdir5(), "verelease-baseline-"));
+    const baselineTmpDir = await mkdtemp7(join19(tmpdir7(), "verelease-baseline-"));
     try {
+      spin?.start("Evaluating compatibility evidence (API diffs, tests & contracts)");
+      const planGit = new GitManager(this.cwd);
       for (const pkg of discovery.packages) {
         const evidence = [];
+        const releaseRef = await planGit.lastReleaseTag(pkg.name) ?? await planGit.latestReleaseTag();
+        if (releaseRef) {
+          const changed = await planGit.changedFilesSince(releaseRef, pkg.directory);
+          if (changed.length === 0) {
+            evidenceMap.set(pkg.name, []);
+            initialBumps.set(pkg.name, {
+              name: pkg.name,
+              currentVersion: pkg.version,
+              proposedVersion: pkg.version,
+              bump: "none",
+              reasons: [`Unchanged since ${releaseRef}.`]
+            });
+            continue;
+          }
+        }
         try {
           const contractEv = await contractAnalyzer.analyze({
             packageName: pkg.name,
@@ -2839,23 +4680,58 @@ var VereleaseCli = class {
           evidence.push(...contractEv);
         } catch {
         }
-        let baselineResult = null;
-        try {
-          if (!pkg.isPrivate) {
-            baselineResult = await baselineFetcher.fetch(pkg.name, baselineTmpDir);
+        if (pkg.ecosystem === "cargo") {
+          try {
+            const cargoEv = await cargoSemVerAnalyzer.analyze({
+              packageName: pkg.name,
+              packagePath: pkg.directory,
+              currentVersion: pkg.version
+            });
+            evidence.push(...cargoEv);
+          } catch {
+          }
+        } else {
+          let baselinePath;
+          let previousVersion;
+          let releaseBaselineCleanup;
+          let baselineOrigin;
+          try {
+            const fromHistory = await gitBaselineResolver.resolve(pkg.name, pkg.directory);
+            if (fromHistory) {
+              baselinePath = fromHistory.entryPointPath;
+              previousVersion = fromHistory.ref;
+              releaseBaselineCleanup = fromHistory.cleanup;
+              baselineOrigin = `git tag ${fromHistory.ref}`;
+            }
+          } catch {
+          }
+          if (!baselinePath && !pkg.isPrivate) {
+            try {
+              const fromRegistry = await baselineFetcher.fetch(pkg.name, baselineTmpDir);
+              if (fromRegistry) {
+                baselinePath = fromRegistry.entryPointPath;
+                previousVersion = fromRegistry.version;
+                baselineOrigin = `npm ${pkg.name}@${fromRegistry.version}`;
+              }
+            } catch {
+            }
+          }
+          try {
+            const apiEv = await apiDiffAnalyzer.analyze({
+              packageName: pkg.name,
+              packagePath: pkg.directory,
+              currentVersion: pkg.version,
+              baselinePath,
+              previousVersion
+            });
+            evidence.push(...apiEv);
+          } catch {
+          } finally {
+            await releaseBaselineCleanup?.().catch(() => void 0);
+          }
+          if (baselineOrigin) {
+            comparedAgainst.set(pkg.name, baselineOrigin);
           }
-        } catch {
-        }
-        try {
-          const apiEv = await apiDiffAnalyzer.analyze({
-            packageName: pkg.name,
-            packagePath: pkg.directory,
-            currentVersion: pkg.version,
-            baselinePath: baselineResult?.entryPointPath,
-            previousVersion: baselineResult?.version
-          });
-          evidence.push(...apiEv);
-        } catch {
         }
         if (testSuiteAnalyzer) {
           try {
@@ -2874,14 +4750,13 @@ var VereleaseCli = class {
           pkg.version,
           evidence,
           config.versioning,
-          options.channel || "stable"
+          channel
         );
         const forced = options.forceBump?.[pkg.name] || options.defaultBump;
         let bump = forced || decision.bump;
         let proposedVersion = decision.proposedVersion;
         const reasons = [...decision.reasons];
         if (forced && decision.bump === "none") {
-          const channel = options.channel || config.versioning?.channel || "stable";
           if (channel !== "stable") {
             const baseBump = `pre${forced}`;
             proposedVersion = semver4.inc(pkg.version, baseBump, channel) || pkg.version;
@@ -2892,10 +4767,20 @@ var VereleaseCli = class {
         }
         if (!pkg.isPrivate) {
           try {
-            const publishedVersions = await npmPublisher.getPublishedVersions(pkg.name);
-            const channel = options.channel || config.versioning?.channel || "stable";
-            if (publishedVersions.includes(proposedVersion) || bump !== "none" && publishedVersions.includes(pkg.version)) {
-              reasons.push(`Version ${proposedVersion} is already published on npm registry.`);
+            let publishedVersions = [];
+            const registryName = pkg.ecosystem === "cargo" ? "crates.io" : "npm registry";
+            if (pkg.ecosystem === "cargo") {
+              const res = await cargoPublisher.queryCratesIo(pkg.name);
+              publishedVersions = res.versions;
+            } else {
+              publishedVersions = await npmPublisher.getPublishedVersions(pkg.name);
+            }
+            const proposedCollides = publishedVersions.includes(proposedVersion);
+            const currentCollidesWithoutBump = bump === "none" && publishedVersions.includes(pkg.version);
+            if (proposedCollides || currentCollidesWithoutBump) {
+              reasons.push(
+                proposedCollides ? `Version ${proposedVersion} is already published on ${registryName}.` : `Current version ${pkg.version} is already published on ${registryName}; a bump is required.`
+              );
               let nextCandidate = proposedVersion;
               if (channel !== "stable") {
                 const baseBump = bump === "none" ? "patch" : bump;
@@ -2922,6 +4807,14 @@ var VereleaseCli = class {
           } catch {
           }
         }
+        const origin = comparedAgainst.get(pkg.name);
+        if (origin) {
+          reasons.push(`Compared against ${origin}.`);
+        } else if (pkg.ecosystem !== "cargo") {
+          reasons.push(
+            "No previous release to compare against: this package has no release tag and is not published. Its first release cannot be inferred from an API diff."
+          );
+        }
         initialBumps.set(pkg.name, {
           name: pkg.name,
           currentVersion: pkg.version,
@@ -2930,10 +4823,12 @@ var VereleaseCli = class {
           reasons
         });
       }
+      spin?.stop("Compatibility evidence evaluated");
     } finally {
-      await rm4(baselineTmpDir, { recursive: true, force: true }).catch(() => {
+      await rm6(baselineTmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
+    spin?.start("Propagating dependency updates across workspace graph");
     const propagator = new VersionPropagator(discovery.graph);
     const { bumps: finalBumps, dependencyUpdates } = propagator.propagate(initialBumps);
     const publishOrder = discovery.graph.getTopologicalOrder();
@@ -2949,7 +4844,7 @@ var VereleaseCli = class {
         pkg.version,
         evidence,
         config.versioning,
-        options.channel || "stable"
+        channel
       );
       packagePlans.push({
         name: pkg.name,
@@ -2957,11 +4852,12 @@ var VereleaseCli = class {
         currentVersion: pkg.version,
         proposedVersion: bumpTarget.proposedVersion,
         bump: bumpTarget.bump,
-        channel: options.channel || "stable",
+        channel,
         evidence,
         reasons: bumpTarget.reasons,
         confidence: decision.confidence,
         requiresApproval: decision.requiresApproval,
+        ...decision.blocked ? { blocked: true } : {},
         dependentUpdates: depUpdates.map((d) => ({
           dependentName: pkgName,
           dependencyName: d.dependencyName,
@@ -2970,15 +4866,17 @@ var VereleaseCli = class {
           newRange: d.newRange
         })),
         filesToUpdate: [pkg.manifestPath],
-        publish: !pkg.isPrivate && bumpTarget.bump !== "none"
+        publish: !pkg.isPrivate && bumpTarget.bump !== "none",
+        ecosystem: pkg.ecosystem
       });
     }
+    spin?.stop(`Calculated release plan [Channel: ${colors3.cyan(channel)}]`);
     const plan = {
       schemaVersion: 1,
       id: `plan-${Date.now()}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       rootDirectory: this.cwd,
-      channel: options.channel || "stable",
+      channel,
       packages: packagePlans,
       publishOrder,
       summary: {
@@ -2993,6 +4891,11 @@ var VereleaseCli = class {
     return { plan, evidenceMap };
   }
   async runPlanCommand(options = {}) {
+    if (!options.json) {
+      prompts3.intro(
+        colors3.cyan(colors3.bold("\u25C9 Verelease")) + colors3.dim(" evidence-based release plan")
+      );
+    }
     const { plan } = await this.createPlan(options);
     if (options.json) {
       console.log(JSON.stringify(plan, null, 2));
@@ -3000,198 +4903,269 @@ var VereleaseCli = class {
     }
     this.printPlan(plan);
     try {
-      const verelDir = join13(this.cwd, ".verelease");
+      const verelDir = join19(this.cwd, ".verelease");
       await mkdir6(verelDir, { recursive: true });
-      await writeFile5(
-        join13(verelDir, "release-plan.json"),
+      await writeFile6(
+        join19(verelDir, "release-plan.json"),
         JSON.stringify(plan, null, 2),
         "utf8"
       );
     } catch {
     }
+    prompts3.outro(
+      plan.summary.bumpedPackages === 0 ? colors3.green("\u2728 All packages are up to date.") : colors3.cyan(
+        `Plan ready: run ${colors3.bold(`verelease release --channel ${plan.channel}`)} to execute.`
+      )
+    );
     return plan;
   }
   async runReleaseCommand(options = {}) {
+    if (!options.dryRun) {
+      const git2 = new GitManager(this.cwd);
+      let isClean;
+      try {
+        isClean = await git2.isClean();
+      } catch (error) {
+        throw new Error(
+          "Cannot verify that the release working tree is clean. Run verelease from a Git repository before publishing.",
+          { cause: error }
+        );
+      }
+      if (!isClean) {
+        throw new Error(
+          "Refusing to release from a dirty working tree. Commit, stash, or remove all changes before publishing."
+        );
+      }
+    }
+    if (!options.json) {
+      prompts3.intro(
+        colors3.cyan(colors3.bold("\u25C9 Verelease")) + colors3.dim(
+          ` release pipeline [${colors3.bold(options.channel || "auto")}]` + (options.dryRun ? colors3.yellow(" (DRY RUN)") : "")
+        )
+      );
+    }
     const { plan, evidenceMap } = await this.createPlan(options);
-    console.log(`
-\u{1F680} Verelease Pipeline [Channel: ${plan.channel}, Dry-run: ${!!options.dryRun}]
-`);
     this.printPlan(plan);
     if (plan.summary.bumpedPackages === 0) {
-      console.log("\n\u2728 No packages require release.");
+      prompts3.outro(colors3.green("\u2728 No packages require release."));
       return;
     }
     const publishable = plan.packages.filter((p) => p.publish && p.bump !== "none");
     const internalBumps = plan.packages.filter((p) => !p.publish && p.bump !== "none");
-    const promptDescription = publishable.length > 0 ? `publishing ${publishable.map((p) => `${p.name}@${p.proposedVersion}`).join(", ")}` + (internalBumps.length > 0 ? ` and bumping ${internalBumps.length} internal package(s)` : "") : `bumping ${internalBumps.length} internal package(s)`;
-    const shouldPrompt = !options.dryRun && !options.yes && !process.env.CI && process.stdin.isTTY;
-    if (shouldPrompt) {
-      const confirmed = await promptConfirm(
-        `
-? Proceed with ${promptDescription}? [y/N] `
-      );
-      if (!confirmed) {
-        console.log("\n\u274C Release cancelled by user. No manifests, lockfiles, or packages were modified.\n");
+    const promptDescription = publishable.length > 0 ? `publishing ${publishable.map((p) => colors3.cyan(`${p.name}@${p.proposedVersion}`)).join(", ")}` + (internalBumps.length > 0 ? ` and bumping ${internalBumps.length} internal package(s)` : "") : `bumping ${internalBumps.length} internal package(s)`;
+    const isInteractive = !options.dryRun && !options.yes && !process.env.CI && process.stdin.isTTY;
+    const npmPublisher = new NpmPublishProvider();
+    const cargoPublisher = new CargoPublishProvider();
+    const hasNpmPackages = publishable.some((p) => p.ecosystem !== "cargo");
+    const hasCargoPackages = publishable.some((p) => p.ecosystem === "cargo");
+    if (publishable.length > 0 && !options.dryRun) {
+      if (hasNpmPackages) {
+        const authStatus = await npmPublisher.checkAuth();
+        if (!authStatus.authenticated) {
+          if (isInteractive) {
+            await npmPublisher.ensureAuth({ interactive: true });
+          } else {
+            throw new NpmAuthError({
+              message: "You are not logged in to npm. Run 'npm login' or configure NPM_TOKEN / NODE_AUTH_TOKEN in CI."
+            });
+          }
+        }
+      }
+      if (hasCargoPackages) {
+        const authStatus = await cargoPublisher.checkAuth();
+        if (!authStatus.authenticated) {
+          if (isInteractive) {
+            await cargoPublisher.ensureAuth({ interactive: true });
+          } else {
+            throw new CargoAuthError({
+              message: "Missing crates.io token. Set CARGO_REGISTRY_TOKEN or configure credentials."
+            });
+          }
+        }
+      }
+    }
+    if (isInteractive) {
+      const confirmed = await prompts3.confirm({
+        message: `Proceed with ${promptDescription}?`,
+        initialValue: true
+      });
+      if (prompts3.isCancel(confirmed) || !confirmed) {
+        prompts3.cancel("Release cancelled by user. No manifests, lockfiles, or packages were modified.");
         return;
       }
     }
-    const mutator = new TransactionalManifestMutator();
+    if (options.dryRun) {
+      prompts3.log.info(colors3.yellow("DRY RUN: Manifest mutations, changelogs, git tags, and registry publishing skipped."));
+      prompts3.outro(colors3.green("Dry run completed successfully."));
+      return;
+    }
     const lockfileAdapter = new AutoLockfileAdapter();
-    const npmPublisher = new NpmPublishProvider();
     const ai = new TanStackReleaseAI();
     const git = new GitManager(this.cwd);
-    let transaction;
-    const changelogBackups = /* @__PURE__ */ new Map();
-    if (!options.dryRun) {
-      console.log("\n\u{1F4E6} Applying version bumps to manifests...");
-      transaction = await mutator.applyPlan(plan);
-      console.log(`\u2713 Updated ${transaction.modifiedFiles.length} manifest files`);
-      console.log(`
-\u{1F512} Regenerating lockfile using ${lockfileAdapter.packageManager}...`);
-      const lockRes = await lockfileAdapter.regenerateLockfile(this.cwd);
-      if (!lockRes.success) {
-        console.error(`\u274C Lockfile regeneration failed: ${lockRes.output}`);
-        await transaction.rollback();
-        console.log("\u21A9 Rolled back manifest updates");
-        process.exit(1);
-      }
-      console.log("\u2713 Lockfile regenerated successfully");
-      console.log("\n\u{1F916} Generating changelogs & migration documentation via AI layer...");
-      for (const pkgPlan of plan.packages) {
-        if (pkgPlan.bump === "none") continue;
-        const evidence = evidenceMap.get(pkgPlan.name) || [];
-        const changelog = await ai.generateChangelog({
-          packageName: pkgPlan.name,
-          previousVersion: pkgPlan.currentVersion,
-          newVersion: pkgPlan.proposedVersion,
-          evidence
-        });
-        const changelogPath = join13(pkgPlan.directory, "CHANGELOG.md");
-        let existingChangelog = null;
-        try {
-          existingChangelog = await readFile7(changelogPath, "utf8");
-        } catch {
-          existingChangelog = null;
+    const spin = process.stdout.isTTY ? prompts3.spinner() : void 0;
+    const releaseProgram = executeReleaseTransaction(
+      {
+        plan,
+        cwd: this.cwd,
+        lockfileAdapter,
+        onStep: (msg) => {
+          spin?.message(msg);
+        },
+        onRollback: (msg) => {
+          prompts3.log.warn(colors3.yellow(`\u21A9 ${msg}`));
         }
-        changelogBackups.set(changelogPath, existingChangelog);
-        await writeFile5(
-          changelogPath,
-          `${changelog.markdown}
+      },
+      (scope) => Effect4.gen(function* () {
+        spin?.start("Generating changelogs & migration documentation via AI layer");
+        for (const pkgPlan of plan.packages) {
+          if (pkgPlan.bump === "none") continue;
+          const evidence = evidenceMap.get(pkgPlan.name) || [];
+          const changelog = yield* Effect4.promise(
+            () => ai.generateChangelog({
+              packageName: pkgPlan.name,
+              previousVersion: pkgPlan.currentVersion,
+              newVersion: pkgPlan.proposedVersion,
+              evidence
+            })
+          );
+          const changelogPath = join19(pkgPlan.directory, "CHANGELOG.md");
+          let existingChangelog = null;
+          try {
+            existingChangelog = yield* Effect4.promise(() => readFile14(changelogPath, "utf8"));
+          } catch {
+            existingChangelog = null;
+          }
+          scope.backupChangelog(changelogPath, existingChangelog);
+          yield* Effect4.promise(
+            () => writeFile6(
+              changelogPath,
+              `${changelog.markdown}
 
 ${existingChangelog || ""}`.trim() + "\n",
-          "utf8"
-        );
-        console.log(`  \u2713 Updated ${pkgPlan.name} CHANGELOG.md`);
-        if (pkgPlan.bump === "major") {
-          const breakingEvidence = evidence.filter((e) => e.severity === "major");
-          const guide = await ai.generateMigrationGuide({
-            packageName: pkgPlan.name,
-            previousVersion: pkgPlan.currentVersion,
-            newVersion: pkgPlan.proposedVersion,
-            breakingChanges: breakingEvidence
-          });
-          const migrationsDir = join13(pkgPlan.directory, "docs", "migrations");
-          await mkdir6(migrationsDir, { recursive: true });
-          const guidePath = join13(
-            migrationsDir,
-            `${pkgPlan.currentVersion.split(".")[0]}-to-${pkgPlan.proposedVersion.split(".")[0]}.md`
+              "utf8"
+            )
           );
-          await writeFile5(guidePath, guide.markdown, "utf8");
-          console.log(`  \u2713 Generated migration guide: ${guidePath}`);
-        }
-      }
-      if (options.tag) {
-        try {
-          console.log("\n\u{1F3F7}\uFE0F Creating Git release commit and tags...");
-          await git.createReleaseCommit([], `chore(release): publish version ${plan.id}`);
-          for (const pkgPlan of plan.packages) {
-            if (pkgPlan.publish) {
-              const tagName = git.formatTagName({
+          if (pkgPlan.bump === "major") {
+            const breakingEvidence = evidence.filter((e) => e.severity === "major");
+            const guide = yield* Effect4.promise(
+              () => ai.generateMigrationGuide({
                 packageName: pkgPlan.name,
-                version: pkgPlan.proposedVersion
-              });
-              await git.createTag(tagName);
-              console.log(`  \u2713 Created git tag: ${tagName}`);
-            }
+                previousVersion: pkgPlan.currentVersion,
+                newVersion: pkgPlan.proposedVersion,
+                breakingChanges: breakingEvidence
+              })
+            );
+            const migrationsDir = join19(pkgPlan.directory, "docs", "migrations");
+            yield* Effect4.promise(async () => {
+              await mkdir6(migrationsDir, { recursive: true });
+              const guidePath = join19(
+                migrationsDir,
+                `${pkgPlan.currentVersion.split(".")[0]}-to-${pkgPlan.proposedVersion.split(".")[0]}.md`
+              );
+              await writeFile6(guidePath, guide.markdown, "utf8");
+              scope.trackGeneratedFile(guidePath);
+            });
           }
-        } catch (err) {
-          console.warn(`  \u26A0\uFE0F Git tagging warning: ${err.message || String(err)}`);
         }
-      }
-    } else {
-      console.log("\n[DRY RUN] Skipped manifest, lockfile, changelog mutations, and git tags.");
-    }
-    console.log("\n\u{1F4E4} Publishing packages in dependency order:");
-    for (const pkgName of plan.publishOrder) {
-      const pkgPlan = plan.packages.find((p) => p.name === pkgName);
-      if (!pkgPlan || !pkgPlan.publish) continue;
-      console.log(`
-  \u2192 Publishing ${pkgPlan.name}@${pkgPlan.proposedVersion}...`);
-      const result = await npmPublisher.publish({
-        packagePlan: pkgPlan,
-        fullPlan: plan,
-        dryRun: !!options.dryRun,
-        extraArgs: options.otp ? ["--otp", options.otp] : void 0
-      });
-      if (result.published) {
-        console.log(`    \u2713 ${pkgPlan.name}@${pkgPlan.proposedVersion} published [tag: ${result.distTag}]`);
-      } else {
-        console.error(`    \u274C Failed to publish ${pkgPlan.name}: ${result.error}`);
-        if (!options.dryRun) {
-          console.log("\n\u21A9 Rolling back manifest updates due to publish failure...");
-          if (transaction) {
-            await transaction.rollback();
-            console.log("  \u2713 Restored manifests to previous versions");
+        spin?.stop("Changelogs and documentation generated");
+        spin?.start("Publishing packages to registries");
+        for (const pkgName of plan.publishOrder) {
+          const pkgPlan = plan.packages.find((p) => p.name === pkgName);
+          if (!pkgPlan || !pkgPlan.publish) continue;
+          const isCargo = pkgPlan.ecosystem === "cargo";
+          const registryLabel = isCargo ? "crates.io" : "npm registry";
+          spin?.message(`Publishing ${colors3.bold(pkgPlan.name)}@${pkgPlan.proposedVersion} to ${registryLabel}`);
+          const result = yield* Effect4.promise(
+            () => isCargo ? cargoPublisher.publish({
+              packagePlan: pkgPlan,
+              fullPlan: plan,
+              dryRun: !!options.dryRun
+            }) : npmPublisher.publish({
+              packagePlan: pkgPlan,
+              fullPlan: plan,
+              dryRun: !!options.dryRun,
+              extraArgs: options.otp ? ["--otp", options.otp] : void 0
+            })
+          );
+          if (!result.published) {
+            return yield* Effect4.fail(
+              new PublishError({
+                packageName: pkgPlan.name,
+                message: result.error || `${registryLabel} publish failed`
+              })
+            );
           }
-          for (const [chPath, original] of changelogBackups) {
+          prompts3.log.success(
+            colors3.green(
+              `Published ${colors3.bold(pkgPlan.name)}@${pkgPlan.proposedVersion} [${registryLabel}]`
+            )
+          );
+        }
+        spin?.stop("All packages published successfully");
+        if (options.tag) {
+          spin?.start("Creating Git release commit and tags");
+          yield* Effect4.promise(async () => {
             try {
-              if (original === null) {
-                await unlink(chPath);
-              } else {
-                await writeFile5(chPath, original, "utf8");
+              await git.createReleaseCommit([], `chore(release): publish version ${plan.id}`);
+              for (const pkgPlan of plan.packages) {
+                if (pkgPlan.publish) {
+                  const tagName = git.formatTagName({
+                    packageName: pkgPlan.name,
+                    version: pkgPlan.proposedVersion
+                  });
+                  await git.createTag(tagName);
+                }
               }
-            } catch {
+            } catch (err) {
+              prompts3.log.warn(`Git tagging warning: ${err.message || String(err)}`);
             }
-          }
-          console.log("  \u2713 Restored changelog files");
-          await lockfileAdapter.regenerateLockfile(this.cwd);
-          console.log("  \u2713 Synchronized lockfile\n");
-          process.exit(1);
+          });
+          spin?.stop("Git commit and tags created");
         }
-      }
+      })
+    );
+    const exit = await Effect4.runPromiseExit(releaseProgram);
+    if (Exit2.isFailure(exit)) {
+      prompts3.log.error(
+        colors3.red("Publish failed. Transactional rollback has restored all files to their clean state.")
+      );
+      process.exit(1);
     }
-    console.log("\n\u{1F389} Release completed successfully!");
+    prompts3.outro(colors3.green(colors3.bold("\u{1F389} Release completed successfully!")));
   }
   async runExplainCommand(packageName) {
+    prompts3.intro(
+      colors3.cyan(colors3.bold("\u25C9 Verelease")) + colors3.dim(` explanation for ${colors3.bold(packageName)}`)
+    );
     const { plan, evidenceMap } = await this.createPlan();
     const pkgPlan = plan.packages.find((p) => p.name === packageName);
     if (!pkgPlan) {
-      console.error(`Package "${packageName}" not found in workspace.`);
+      prompts3.log.error(`Package "${packageName}" not found in workspace.`);
       return;
     }
     const evidence = evidenceMap.get(packageName) || [];
-    console.log(`
-\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-    console.log(`  EXPLANATION FOR ${packageName}`);
-    console.log(`\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
-`);
-    console.log(`Current Version:  ${pkgPlan.currentVersion}`);
-    console.log(`Proposed Version: ${pkgPlan.proposedVersion} [${pkgPlan.bump.toUpperCase()}]`);
-    console.log(`Confidence:       ${(pkgPlan.confidence * 100).toFixed(0)}%`);
-    console.log(`Requires Review:  ${pkgPlan.requiresApproval ? "YES" : "NO"}
-`);
-    console.log(`Evidence items (${evidence.length}):`);
+    const badge = pkgPlan.bump === "major" ? colors3.red("\u{1F534} MAJOR") : pkgPlan.bump === "minor" ? colors3.yellow("\u{1F7E1} MINOR") : pkgPlan.bump === "patch" ? colors3.green("\u{1F7E2} PATCH") : colors3.dim("\u26AA NONE");
+    const lines = [
+      `${colors3.bold("Current Version:")}  ${pkgPlan.currentVersion}`,
+      `${colors3.bold("Proposed Version:")} ${colors3.cyan(colors3.bold(pkgPlan.proposedVersion))} [${badge}]`,
+      `${colors3.bold("Confidence:")}       ${(pkgPlan.confidence * 100).toFixed(0)}%`,
+      `${colors3.bold("Requires Review:")}  ${pkgPlan.requiresApproval ? colors3.yellow("YES") : colors3.green("NO")}`,
+      "",
+      `${colors3.bold(`Evidence Items (${evidence.length}):`)}`
+    ];
     for (const ev of evidence) {
-      console.log(`  \u2022 [${ev.source.toUpperCase()}] (${ev.severity.toUpperCase()}) ${ev.title}`);
-      console.log(`    ${ev.description}
-`);
+      lines.push(`  \u2022 [${colors3.cyan(ev.source.toUpperCase())}] (${colors3.bold(ev.severity.toUpperCase())}) ${ev.title}`);
+      lines.push(`    ${colors3.dim(ev.description)}`);
     }
     if (pkgPlan.reasons.length > 0) {
-      console.log("Decision reasons:");
+      lines.push("");
+      lines.push(colors3.bold("Decision Reasons:"));
       for (const reason of pkgPlan.reasons) {
-        console.log(`  ${reason}`);
+        lines.push(`  \u2022 ${reason}`);
       }
     }
+    prompts3.note(lines.join("\n"), `Evidence Breakdown`);
+    prompts3.outro("Explanation complete.");
   }
   async runGuideCommand(options = {}) {
     if (options.json) {
@@ -3199,18 +5173,19 @@ ${existingChangelog || ""}`.trim() + "\n",
         JSON.stringify(
           {
             name: "verelease",
-            description: "Compatibility-aware SemVer release engine",
+            description: "Universal compatibility-aware SemVer release engine",
+            supportedEcosystems: ["npm", "cargo"],
             rules: [
-              "Never manually edit 'version' in package.json",
+              "Never manually edit 'version' in package.json or Cargo.toml",
               "SemVer bumps are calculated from contract tests, API diffs, and dependency ranges",
               "Pass --yes to bypass interactive prompts in CI"
             ],
             commands: {
-              plan: "verel plan [--channel <channel>] [--json]",
-              release: "verel release [--channel <channel>] [-y, --yes]",
-              explain: "verel explain <pkg>",
-              guide: "verel guide [--json]",
-              init: "verel init"
+              plan: "verelease plan [--channel <channel>] [--json]",
+              release: "verelease release [--channel <channel>] [-y, --yes]",
+              explain: "verelease explain <pkg>",
+              guide: "verelease guide [--json]",
+              init: "verelease init"
             },
             configuration: "verelease.config.ts",
             contractsDirectory: ".verelease/contracts",
@@ -3222,37 +5197,33 @@ ${existingChangelog || ""}`.trim() + "\n",
       );
       return;
     }
-    console.log(`
-# Verelease Agent Guide
-
-Verelease is an evidence-based SemVer release engine for JavaScript & TypeScript.
-
-## Core Rules for AI Coding Agents
-1. **NEVER manually edit "version" in package.json**: Always let Verelease determine versions.
-2. **Inspect first**: Run \`pnpm verel plan\` to preview proposed version bumps without modifying files.
-3. **Diagnose bumps**: Run \`pnpm verel explain <pkg>\` to understand the evidence behind any bump.
-4. **Automated releases**: In CI or automated workflows, run \`pnpm verel release --yes\` to bypass prompts.
-5. **Interactive releases**: When run locally, Verelease asks for [y/N] confirmation and supports Touch ID / WebAuthn.
-
-## Command Reference
-- \`pnpm verel plan\`                     Preview release plan for stable channel
-- \`pnpm verel plan --channel alpha\`     Preview pre-release bumps for alpha channel
-- \`pnpm verel release\`                  Interactive release pipeline
-- \`pnpm verel release -y\`               Non-interactive release (for agents/CI)
-- \`pnpm verel explain <package>\`        Inspect compatibility evidence and decision reasons
-- \`pnpm verel init\`                     Initialize config, contracts, and AGENTS.md
-
-## Configuration
-Config is loaded from \`verelease.config.ts\` or \`verelease.config.js\`.
-Contract test suites live in \`.verelease/contracts/\`.
-`);
+    prompts3.intro(colors3.cyan(colors3.bold("\u25C9 Verelease")) + colors3.dim(" agent guide"));
+    const content = [
+      colors3.bold("Core Rules for AI Coding Agents:"),
+      `1. ${colors3.bold("NEVER manually edit 'version' in package.json or Cargo.toml")}: Always let Verelease compute and bump versions based on compatibility evidence.`,
+      `2. ${colors3.bold("Inspect first")}: Run ${colors3.cyan("verelease plan")} to preview proposed version bumps across npm and Cargo packages.`,
+      `3. ${colors3.bold("Diagnose bumps")}: Run ${colors3.cyan("verelease explain <pkg>")} to inspect compatibility evidence (TypeScript AST diffs, Rust semver-checks, test suites).`,
+      `4. ${colors3.bold("Automated releases")}: In CI or agents, run ${colors3.cyan("verelease release --yes")} to bypass prompts.`,
+      `5. ${colors3.bold("Interactive releases")}: Locally, Verelease prompts [y/N] and supports npm 2FA & crates.io tokens.`,
+      "",
+      colors3.bold("Command Reference:"),
+      `\u2022 ${colors3.cyan("verelease plan")}                     Preview release plan for stable channel`,
+      `\u2022 ${colors3.cyan("verelease plan --channel alpha")}     Preview pre-release bumps for alpha channel`,
+      `\u2022 ${colors3.cyan("verelease release")}                  Interactive release pipeline`,
+      `\u2022 ${colors3.cyan("verelease release -y")}               Non-interactive release (for agents/CI)`,
+      `\u2022 ${colors3.cyan("verelease explain <package>")}        Inspect evidence and decision reasons`,
+      `\u2022 ${colors3.cyan("verelease init")}                     Initialize config, contracts, and AGENTS.md`
+    ].join("\n");
+    prompts3.note(content, "Universal Agent Guide & Workflow");
+    prompts3.outro("Guide complete.");
   }
   async runInitCommand(options = {}) {
-    const configPath = join13(this.cwd, "verelease.config.ts");
-    const contractsDir = join13(this.cwd, ".verelease", "contracts");
-    const agentsPath = join13(this.cwd, "AGENTS.md");
-    const pkgJsonPath = join13(this.cwd, "package.json");
-    console.log("\n\u{1F680} Initializing Verelease in current project...\n");
+    const configPath = join19(this.cwd, "verelease.config.ts");
+    const contractsDir = join19(this.cwd, ".verelease", "contracts");
+    const agentsPath = join19(this.cwd, "AGENTS.md");
+    const gitignorePath = join19(this.cwd, ".gitignore");
+    const pkgJsonPath = join19(this.cwd, "package.json");
+    prompts3.intro(colors3.cyan(colors3.bold("\u25C9 Verelease")) + colors3.dim(" project initialization"));
     if (!existsSync(configPath)) {
       const sampleConfig = `import { defineConfig } from "verelease/config";
 
@@ -3275,21 +5246,48 @@ export default defineConfig({
   },
 });
 `;
-      await writeFile5(configPath, sampleConfig, "utf8");
-      console.log("  \u2713 Created verelease.config.ts");
+      await writeFile6(configPath, sampleConfig, "utf8");
+      prompts3.log.success(colors3.green("Created verelease.config.ts"));
     } else {
-      console.log("  \u2022 verelease.config.ts already exists");
+      prompts3.log.info("verelease.config.ts already exists");
     }
     if (!existsSync(contractsDir)) {
       await mkdir6(contractsDir, { recursive: true });
-      await writeFile5(
-        join13(contractsDir, "README.md"),
+      await writeFile6(
+        join19(contractsDir, "README.md"),
         "# Verelease Contracts\n\nPlace consumer-driven contract definitions (.json or .yaml) here.\n",
         "utf8"
       );
-      console.log("  \u2713 Created .verelease/contracts/");
+      prompts3.log.success(colors3.green("Created .verelease/contracts/"));
     } else {
-      console.log("  \u2022 .verelease/contracts/ already exists");
+      prompts3.log.info(".verelease/contracts/ already exists");
+    }
+    const generatedIgnoreEntries = [
+      ".verelease/*",
+      "!.verelease/contracts/",
+      ".vitest/"
+    ];
+    const existingGitignore = existsSync(gitignorePath) ? await readFile14(gitignorePath, "utf8") : "";
+    const existingIgnoreLines = new Set(
+      existingGitignore.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+    );
+    const missingIgnoreEntries = generatedIgnoreEntries.filter(
+      (entry) => !existingIgnoreLines.has(entry)
+    );
+    if (missingIgnoreEntries.length > 0) {
+      const separator = existingGitignore.length === 0 ? "" : existingGitignore.endsWith("\n") ? "\n" : "\n\n";
+      await writeFile6(
+        gitignorePath,
+        `${existingGitignore}${separator}# Verelease generated files
+${missingIgnoreEntries.join("\n")}
+`,
+        "utf8"
+      );
+      prompts3.log.success(
+        colors3.green("Ignored generated Verelease and Vitest state in .gitignore")
+      );
+    } else {
+      prompts3.log.info(".gitignore already excludes generated Verelease and Vitest state");
     }
     const agentGuidance = `
 ## Releases & Versioning (Verelease)
@@ -3301,24 +5299,24 @@ This repository uses [Verelease](https://github.com/ivanjeremic/verelease) for a
 - **NEVER manually edit "version" in package.json.**
 `;
     if (!existsSync(agentsPath)) {
-      await writeFile5(agentsPath, `# Agent Guidelines
+      await writeFile6(agentsPath, `# Agent Guidelines
 ${agentGuidance}
 `, "utf8");
-      console.log("  \u2713 Created AGENTS.md with Verelease instructions");
+      prompts3.log.success(colors3.green("Created AGENTS.md with Verelease instructions"));
     } else {
-      const currentContent = await readFile7(agentsPath, "utf8");
+      const currentContent = await readFile14(agentsPath, "utf8");
       if (!currentContent.includes("Verelease")) {
-        await writeFile5(agentsPath, `${currentContent.trim()}
+        await writeFile6(agentsPath, `${currentContent.trim()}
 ${agentGuidance}
 `, "utf8");
-        console.log("  \u2713 Appended Verelease instructions to AGENTS.md");
+        prompts3.log.success(colors3.green("Appended Verelease instructions to AGENTS.md"));
       } else {
-        console.log("  \u2022 AGENTS.md already contains Verelease instructions");
+        prompts3.log.info("AGENTS.md already contains Verelease instructions");
       }
     }
     if (existsSync(pkgJsonPath)) {
       try {
-        const pkg = JSON.parse(await readFile7(pkgJsonPath, "utf8"));
+        const pkg = JSON.parse(await readFile14(pkgJsonPath, "utf8"));
         pkg.scripts = pkg.scripts || {};
         let modified = false;
         if (!pkg.scripts.plan) {
@@ -3330,127 +5328,237 @@ ${agentGuidance}
           modified = true;
         }
         if (modified) {
-          await writeFile5(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-          console.log("  \u2713 Added 'plan' and 'release' scripts to package.json");
+          await writeFile6(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+          prompts3.log.success(colors3.green("Added 'plan' and 'release' scripts to package.json"));
         }
       } catch {
       }
     }
-    console.log("\n\u2728 Verelease successfully initialized!\n");
+    prompts3.outro(colors3.green(colors3.bold("\u2728 Verelease successfully initialized!")));
   }
   printPlan(plan) {
-    console.log(`
-\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-    console.log(`  VERELEASE RELEASE PLAN`);
-    console.log(`  Channel: ${plan.channel} | Packages: ${plan.summary.totalPackages} | Bumps: ${plan.summary.bumpedPackages}`);
-    console.log(`\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
-`);
+    const lines = [];
     for (const pkg of plan.packages) {
-      const bumpColor = pkg.bump === "major" ? "\u{1F534} MAJOR" : pkg.bump === "minor" ? "\u{1F7E1} MINOR" : pkg.bump === "patch" ? "\u{1F7E2} PATCH" : "\u26AA NONE";
-      console.log(`${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.proposedVersion} [${bumpColor}]`);
-      console.log(`  Confidence: ${(pkg.confidence * 100).toFixed(0)}% | Publish: ${pkg.publish ? "YES" : "NO"}`);
+      const badge = pkg.bump === "major" ? colors3.red("\u{1F534} MAJOR") : pkg.bump === "minor" ? colors3.yellow("\u{1F7E1} MINOR") : pkg.bump === "patch" ? colors3.green("\u{1F7E2} PATCH") : colors3.dim("\u26AA NONE");
+      const registryName = pkg.ecosystem === "cargo" ? "crates.io" : "npm";
+      const pubTag = pkg.publish ? colors3.cyan(` [${registryName} publish]`) : colors3.dim(" [internal]");
+      if (pkg.blocked) {
+        lines.push(
+          `${colors3.red("\u26D4 BLOCKED")}  ${colors3.bold(pkg.name)}  ${colors3.dim(
+            `would be ${pkg.bump}`
+          )} ${colors3.dim(`(${pkg.currentVersion} \u2192 ${pkg.proposedVersion})`)}${pubTag}`
+        );
+      } else {
+        lines.push(
+          `${badge}  ${colors3.bold(pkg.name)}  ${colors3.dim(pkg.currentVersion)} \u2192 ${colors3.cyan(colors3.bold(pkg.proposedVersion))}${pubTag}`
+        );
+      }
       if (pkg.reasons.length > 0) {
-        console.log("  Reasons:");
-        for (const reason of pkg.reasons) {
-          console.log(`    ${reason}`);
+        for (const reason of pkg.reasons.slice(0, 2)) {
+          lines.push(`       ${colors3.dim("\u2022")} ${colors3.dim(reason)}`);
         }
       }
       if (pkg.dependentUpdates.length > 0) {
-        console.log("  Dependent Updates:");
-        for (const dep of pkg.dependentUpdates) {
-          console.log(`    ${dep.dependentName} depends on ${dep.dependencyName} (${dep.previousRange} \u2192 ${dep.newRange})`);
+        for (const dep of pkg.dependentUpdates.slice(0, 2)) {
+          lines.push(
+            `       ${colors3.dim("\u21B3")} ${colors3.dim(`${dep.dependentName} depends on ${dep.dependencyName} (${dep.previousRange} \u2192 ${dep.newRange})`)}`
+          );
         }
       }
-      console.log("");
+      lines.push("");
     }
+    const summaryLine = [
+      `${colors3.bold(plan.summary.totalPackages)} packages`,
+      `${colors3.green(colors3.bold(plan.summary.bumpedPackages))} bumps`,
+      `(${colors3.green(`${plan.summary.patchBumps} patch`)}, ${colors3.yellow(`${plan.summary.minorBumps} minor`)}, ${colors3.red(`${plan.summary.majorBumps} major`)})`,
+      `Channel: ${colors3.cyan(plan.channel)}`
+    ].join(" | ");
+    lines.push(summaryLine);
+    prompts3.note(lines.join("\n"), `Release Plan Summary`);
   }
 };
 
 // src/bin.ts
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0] || "plan";
-  if (args.includes("--help") || args.includes("-h") || command === "help") {
-    console.log(`
-Usage: verelease [command] [options]
-
-Commands:
-  plan              Preview the release plan without making changes (default)
-  release           Apply version bumps, generate changelogs, and publish
-  explain <pkg>     Explain compatibility evidence and bump decision for a package
-  guide             Show agent-optimized cheat sheet and machine-readable instructions
-  init              Initialize verelease.config.ts, contracts, and AGENTS.md
-
-Options:
-  --channel <name>  Release channel (e.g. stable, alpha, beta, rc) [default: stable]
-  --bump <type>     Manual bump override (patch | minor | major)
-  --dry-run         Simulate pipeline without modifying manifests or publishing
-  -y, --yes         Skip interactive confirmation prompt
-  --otp <code>      One-time password for npm 2FA
-  --tag             Create git commit and tags for release
-  --json            Output machine-readable JSON
-  -h, --help        Show this help message
-`);
-    return;
+var __dirname2 = dirname3(fileURLToPath(import.meta.url));
+async function getCliVersion() {
+  try {
+    const pkgJsonPath = join20(__dirname2, "../package.json");
+    const content = await readFile15(pkgJsonPath, "utf8");
+    const parsed = JSON.parse(content);
+    return parsed.version || "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+var commonArgs = {
+  channel: {
+    type: "string",
+    description: "Release channel (e.g. stable, alpha, beta, rc)"
+  },
+  bump: {
+    type: "string",
+    description: "Manual bump override (patch | minor | major)"
+  },
+  dryRun: {
+    type: "boolean",
+    description: "Simulate pipeline without modifying manifests or publishing"
+  },
+  yes: {
+    type: "boolean",
+    alias: "y",
+    description: "Skip interactive confirmation prompt"
+  },
+  json: {
+    type: "boolean",
+    description: "Output machine-readable JSON"
+  },
+  tag: {
+    type: "boolean",
+    description: "Create git commit and tags for release"
+  },
+  otp: {
+    type: "string",
+    description: "One-time password for npm 2FA"
+  },
+  cwd: {
+    type: "string",
+    description: "Working directory path"
   }
-  const options = {
-    dryRun: args.includes("--dry-run"),
-    json: args.includes("--json"),
-    tag: args.includes("--tag"),
-    yes: args.includes("--yes") || args.includes("-y")
+};
+function toCliOptions(args) {
+  return {
+    channel: args.channel,
+    defaultBump: args.bump,
+    dryRun: Boolean(args.dryRun),
+    yes: Boolean(args.yes),
+    json: Boolean(args.json),
+    tag: Boolean(args.tag),
+    otp: args.otp,
+    cwd: args.cwd
   };
-  const channelIdx = args.indexOf("--channel");
-  if (channelIdx !== -1 && args[channelIdx + 1]) {
-    options.channel = args[channelIdx + 1];
+}
+var subcommandExecuted = false;
+var planCommand = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Preview the release plan without making changes"
+  },
+  args: commonArgs,
+  async run({ args }) {
+    subcommandExecuted = true;
+    const opts = toCliOptions(args);
+    const cli = new VereleaseCli(opts);
+    await cli.runPlanCommand(opts);
   }
-  const bumpIdx = args.indexOf("--bump");
-  if (bumpIdx !== -1 && args[bumpIdx + 1]) {
-    options.defaultBump = args[bumpIdx + 1];
+});
+var releaseCommand = defineCommand({
+  meta: {
+    name: "release",
+    description: "Apply version bumps, generate changelogs, and publish"
+  },
+  args: commonArgs,
+  async run({ args }) {
+    subcommandExecuted = true;
+    const opts = toCliOptions(args);
+    const cli = new VereleaseCli(opts);
+    await cli.runReleaseCommand(opts);
   }
-  const cwdIdx = args.indexOf("--cwd");
-  if (cwdIdx !== -1 && args[cwdIdx + 1]) {
-    options.cwd = args[cwdIdx + 1];
+});
+var versionCommand = defineCommand({
+  meta: {
+    name: "version",
+    description: "Print the verelease version"
+  },
+  async run() {
+    subcommandExecuted = true;
+    console.log(version);
   }
-  const otpIdx = args.indexOf("--otp");
-  if (otpIdx !== -1 && args[otpIdx + 1]) {
-    options.otp = args[otpIdx + 1];
+});
+var explainCommand = defineCommand({
+  meta: {
+    name: "explain",
+    description: "Explain compatibility evidence and bump decision for a package"
+  },
+  args: {
+    package: {
+      type: "positional",
+      description: "Package name to explain (e.g. @verelease/core)",
+      required: false
+    },
+    ...commonArgs
+  },
+  async run({ args }) {
+    subcommandExecuted = true;
+    const opts = toCliOptions(args);
+    const cli = new VereleaseCli(opts);
+    const targetPkg = args.package || args._ && args._[0];
+    if (!targetPkg) {
+      console.error("\n\u274C Please specify a package name to explain, e.g.: verelease explain @verelease/core\n");
+      process.exit(1);
+    }
+    await cli.runExplainCommand(targetPkg);
   }
-  const cli = new VereleaseCli(options);
-  try {
-    switch (command) {
-      case "plan":
-        await cli.runPlanCommand(options);
-        break;
-      case "release":
-        await cli.runReleaseCommand(options);
-        break;
-      case "version":
-        await cli.runReleaseCommand({ ...options, dryRun: false });
-        break;
-      case "guide":
-        await cli.runGuideCommand(options);
-        break;
-      case "init":
-        await cli.runInitCommand(options);
-        break;
-      case "explain":
-        const targetPkg = args[1];
-        if (!targetPkg) {
-          console.error("Please specify a package name to explain, e.g.: verel explain @acme/core");
-          process.exit(1);
-        }
-        await cli.runExplainCommand(targetPkg);
-        break;
-      default:
-        console.log(`Unknown command: ${command}`);
-        console.log(`Run 'verelease --help' for available commands and options.`);
-        process.exit(1);
+});
+var guideCommand = defineCommand({
+  meta: {
+    name: "guide",
+    description: "Show agent-optimized cheat sheet and machine-readable instructions"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output machine-readable JSON"
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory path"
     }
-  } catch (err) {
-    console.error(`
-\u274C Error: ${err.message || String(err)}`);
-    process.exit(1);
+  },
+  async run({ args }) {
+    subcommandExecuted = true;
+    const cli = new VereleaseCli({ cwd: args.cwd });
+    await cli.runGuideCommand({ json: Boolean(args.json) });
   }
-}
-main();
+});
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize verelease.config.ts, contracts, and AGENTS.md"
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Working directory path"
+    }
+  },
+  async run({ args }) {
+    subcommandExecuted = true;
+    const cli = new VereleaseCli({ cwd: args.cwd });
+    await cli.runInitCommand({ cwd: args.cwd });
+  }
+});
+var version = await getCliVersion();
+var mainCommand = defineCommand({
+  meta: {
+    name: "verelease",
+    version,
+    description: "Evidence-based semantic versioning release engine"
+  },
+  args: commonArgs,
+  subCommands: {
+    plan: planCommand,
+    release: releaseCommand,
+    version: versionCommand,
+    explain: explainCommand,
+    guide: guideCommand,
+    init: initCommand
+  },
+  async run({ args }) {
+    if (subcommandExecuted) return;
+    const opts = toCliOptions(args);
+    const cli = new VereleaseCli(opts);
+    await cli.runPlanCommand(opts);
+  }
+});
+void runMain(mainCommand);
 //# sourceMappingURL=bin.js.map