verelease 0.1.2-alpha.0

package/dist/bin.js

@@ -0,0 +1,2380 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { resolve as resolve2, join as join10 } from "path";
+import { writeFile as writeFile5, mkdir as mkdir5, readFile as readFile5, unlink } from "fs/promises";
+
+// ../workspace/dist/graph.js
+var PackageGraphImpl = class {
+  nodes = /* @__PURE__ */ new Map();
+  constructor(packages) {
+    this.buildGraph(packages);
+  }
+  buildGraph(packages) {
+    const packageNames = new Set(packages.map((p) => p.name));
+    for (const pkg of packages) {
+      this.nodes.set(pkg.name, {
+        pkg,
+        dependencies: /* @__PURE__ */ new Map(),
+        dependents: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const pkg of packages) {
+      const node = this.nodes.get(pkg.name);
+      const manifest = pkg.manifest;
+      const depSections = [
+        ["dependencies", manifest.dependencies],
+        ["devDependencies", manifest.devDependencies],
+        ["peerDependencies", manifest.peerDependencies],
+        ["optionalDependencies", manifest.optionalDependencies]
+      ];
+      for (const [depType, deps] of depSections) {
+        if (!deps)
+          continue;
+        for (const [depName, range] of Object.entries(deps)) {
+          if (!packageNames.has(depName))
+            continue;
+          let protocol = "standard";
+          let rawProtocolPrefix = "";
+          if (range.startsWith("workspace:")) {
+            protocol = "workspace";
+            rawProtocolPrefix = "workspace:";
+          } else if (range.startsWith("file:")) {
+            protocol = "file";
+            rawProtocolPrefix = "file:";
+          } else if (range.startsWith("link:")) {
+            protocol = "link";
+            rawProtocolPrefix = "link:";
+          }
+          node.dependencies.set(depName, {
+            name: depName,
+            currentRange: range,
+            type: depType,
+            protocol,
+            rawProtocolPrefix
+          });
+          const depNode = this.nodes.get(depName);
+          if (depNode) {
+            depNode.dependents.add(pkg.name);
+          }
+        }
+      }
+    }
+  }
+  getTopologicalOrder() {
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const [name, node] of this.nodes) {
+      inDegree.set(name, node.dependencies.size);
+    }
+    const queue = [];
+    for (const [name, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(name);
+      }
+    }
+    const order = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      order.push(current);
+      const currentNode = this.nodes.get(current);
+      if (!currentNode)
+        continue;
+      for (const depName of currentNode.dependents) {
+        const currentInDegree = inDegree.get(depName);
+        const newInDegree = currentInDegree - 1;
+        inDegree.set(depName, newInDegree);
+        if (newInDegree === 0) {
+          queue.push(depName);
+        }
+      }
+    }
+    if (order.length < this.nodes.size) {
+      for (const name of this.nodes.keys()) {
+        if (!order.includes(name)) {
+          order.push(name);
+        }
+      }
+    }
+    return order;
+  }
+  getDirectDependents(packageName) {
+    const node = this.nodes.get(packageName);
+    if (!node)
+      return [];
+    return Array.from(node.dependents);
+  }
+  getAllTransitiveDependents(packageName) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...this.getDirectDependents(packageName)];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!visited.has(current)) {
+        visited.add(current);
+        const dependents = this.getDirectDependents(current);
+        for (const dep of dependents) {
+          if (!visited.has(dep)) {
+            queue.push(dep);
+          }
+        }
+      }
+    }
+    return Array.from(visited);
+  }
+  hasCycle() {
+    return this.getCycles().length > 0;
+  }
+  getCycles() {
+    const visited = /* @__PURE__ */ new Set();
+    const recStack = /* @__PURE__ */ new Set();
+    const cycles = [];
+    const dfs = (nodeName, path) => {
+      visited.add(nodeName);
+      recStack.add(nodeName);
+      path.push(nodeName);
+      const node = this.nodes.get(nodeName);
+      if (node) {
+        for (const depName of node.dependencies.keys()) {
+          if (!visited.has(depName)) {
+            dfs(depName, [...path]);
+          } else if (recStack.has(depName)) {
+            const cycleStartIndex = path.indexOf(depName);
+            if (cycleStartIndex !== -1) {
+              cycles.push(path.slice(cycleStartIndex).concat(depName));
+            }
+          }
+        }
+      }
+      recStack.delete(nodeName);
+    };
+    for (const name of this.nodes.keys()) {
+      if (!visited.has(name)) {
+        dfs(name, []);
+      }
+    }
+    return cycles;
+  }
+};
+
+// ../workspace/dist/resolver.js
+import { readFile, stat, readdir } from "fs/promises";
+import { join, relative, resolve } from "path";
+import { parse as parseYaml } from "yaml";
+async function fileExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function dirExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+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);
+  }
+  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
+        };
+      }
+    }
+    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));
+            }
+          }
+        }
+      } else {
+        const exactDir = join(absRootDir, pattern);
+        if (await dirExists(exactDir)) {
+          matchedDirs.add(exactDir);
+        }
+      }
+    }
+    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)
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    const graph = new PackageGraphImpl(packages);
+    return {
+      rootDirectory: absRootDir,
+      packageManager,
+      packages,
+      graph
+    };
+  }
+};
+
+// ../workspace/dist/propagator.js
+import semver from "semver";
+var VersionPropagator = class {
+  graph;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  propagate(initialBumps, options = {}) {
+    const bumps = new Map(initialBumps);
+    const dependencyUpdates = /* @__PURE__ */ new Map();
+    const dependentBump = options.dependentBumpStrategy || "patch";
+    let queue = Array.from(bumps.keys());
+    while (queue.length > 0) {
+      const changedPkgName = queue.shift();
+      const changedTarget = bumps.get(changedPkgName);
+      if (changedTarget.bump === "none")
+        continue;
+      const directDependents = this.graph.getDirectDependents(changedPkgName);
+      for (const dependentName of directDependents) {
+        const depNode = this.graph.nodes.get(dependentName);
+        if (!depNode)
+          continue;
+        const ref = depNode.dependencies.get(changedPkgName);
+        if (!ref)
+          continue;
+        const { currentRange, rawProtocolPrefix } = ref;
+        let cleanRange = currentRange;
+        if (rawProtocolPrefix) {
+          cleanRange = currentRange.slice(rawProtocolPrefix.length);
+        }
+        let isSatisfied = false;
+        if (cleanRange === "*" || cleanRange === "") {
+          isSatisfied = true;
+        } else {
+          isSatisfied = semver.satisfies(changedTarget.proposedVersion, cleanRange);
+        }
+        if (!isSatisfied) {
+          let newRange = `^${changedTarget.proposedVersion}`;
+          if (cleanRange.startsWith("~")) {
+            newRange = `~${changedTarget.proposedVersion}`;
+          }
+          if (rawProtocolPrefix) {
+            newRange = `${rawProtocolPrefix}${newRange}`;
+          }
+          if (!dependencyUpdates.has(dependentName)) {
+            dependencyUpdates.set(dependentName, []);
+          }
+          dependencyUpdates.get(dependentName).push({
+            dependencyName: changedPkgName,
+            previousRange: currentRange,
+            newRange,
+            type: ref.type
+          });
+          const existingDependentBump = bumps.get(dependentName);
+          if (!existingDependentBump || existingDependentBump.bump === "none") {
+            const currentVer = depNode.pkg.version;
+            const nextVer = semver.inc(currentVer, dependentBump) || currentVer;
+            const newTarget = {
+              name: dependentName,
+              currentVersion: currentVer,
+              proposedVersion: nextVer,
+              bump: dependentBump,
+              reasons: [
+                `Dependency ${changedPkgName} bumped to ${changedTarget.proposedVersion}, violating range ${currentRange}`
+              ]
+            };
+            bumps.set(dependentName, newTarget);
+            queue.push(dependentName);
+          }
+        }
+      }
+    }
+    return {
+      bumps,
+      dependencyUpdates
+    };
+  }
+};
+
+// ../semver/dist/engine.js
+import semver2 from "semver";
+var DefaultSemVerDecisionEngine = class {
+  evaluate(packageName, currentVersion, evidence, policy = {}, channel = "stable") {
+    const validCurrent = semver2.valid(currentVersion);
+    if (!validCurrent) {
+      throw new Error(`Invalid SemVer string for package ${packageName}: ${currentVersion}`);
+    }
+    const currentParsed = semver2.parse(validCurrent);
+    const isZeroMajor = currentParsed.major === 0;
+    if (policy.evaluate) {
+      const customBump = policy.evaluate(evidence, { packageName, currentVersion });
+      if (customBump) {
+        return this.createDecision(packageName, currentVersion, customBump, evidence, [`Determined by custom policy evaluation: ${customBump}`], 1, policy, channel);
+      }
+    }
+    let bump = "none";
+    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");
+    if (majorEvidence.length > 0) {
+      if (isZeroMajor && policy.zeroMajor?.breaking === "minor") {
+        bump = "minor";
+        reasons.push(`Detected breaking compatibility changes in 0.x package under zeroMajor policy -> minor bump`);
+      } else {
+        bump = "major";
+        reasons.push(`Detected ${majorEvidence.length} breaking compatibility changes:`);
+      }
+      for (const e of majorEvidence) {
+        reasons.push(`  - [${e.source}] ${e.title}: ${e.description}`);
+        confidenceSum += e.confidence;
+        confidenceCount++;
+      }
+    } else if (minorEvidence.length > 0) {
+      bump = "minor";
+      reasons.push(`Detected ${minorEvidence.length} backward-compatible additions:`);
+      for (const e of minorEvidence) {
+        reasons.push(`  - [${e.source}] ${e.title}: ${e.description}`);
+        confidenceSum += e.confidence;
+        confidenceCount++;
+      }
+    } else if (patchEvidence.length > 0) {
+      bump = "patch";
+      reasons.push(`Detected ${patchEvidence.length} backwards-compatible patches:`);
+      for (const e of patchEvidence) {
+        reasons.push(`  - [${e.source}] ${e.title}: ${e.description}`);
+        confidenceSum += e.confidence;
+        confidenceCount++;
+      }
+    } else {
+      bump = "none";
+      reasons.push("No compatibility changes detected requiring a version bump.");
+    }
+    const confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 1;
+    return this.createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel);
+  }
+  createDecision(packageName, currentVersion, bump, evidence, reasons, confidence, policy, channel) {
+    let proposedVersion = currentVersion;
+    if (bump !== "none") {
+      if (channel && channel !== "stable") {
+        const parsed = semver2.parse(currentVersion);
+        const currentPrerelease = parsed.prerelease;
+        if (currentPrerelease.length > 0 && currentPrerelease[0] === channel) {
+          proposedVersion = semver2.inc(currentVersion, "prerelease", channel) || currentVersion;
+        } else {
+          const baseBump = `pre${bump}`;
+          proposedVersion = semver2.inc(currentVersion, baseBump, channel) || currentVersion;
+        }
+      } else {
+        proposedVersion = semver2.inc(currentVersion, bump) || currentVersion;
+      }
+    }
+    const requiresApproval = bump === "major" && !!policy.requireHumanApprovalForMajor || policy.minimumConfidenceForAutomaticRelease !== void 0 && confidence < policy.minimumConfidenceForAutomaticRelease;
+    return {
+      packageName,
+      currentVersion,
+      bump,
+      proposedVersion,
+      confidence,
+      reasons,
+      evidence,
+      requiresApproval
+    };
+  }
+};
+
+// ../contracts/dist/store.js
+import { readFile as readFile2, writeFile, mkdir, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import semver3 from "semver";
+var FileContractStore = class {
+  directory;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  async ensureDir() {
+    try {
+      await mkdir(this.directory, { recursive: true });
+    } catch {
+    }
+  }
+  async listContracts(packageName) {
+    await this.ensureDir();
+    const contracts = [];
+    try {
+      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);
+          try {
+            const content = await readFile2(fullPath, "utf8");
+            const parsed = JSON.parse(content);
+            if (!packageName || parsed.package === packageName) {
+              contracts.push(parsed);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return contracts;
+  }
+  async getContract(id) {
+    const contracts = await this.listContracts();
+    return contracts.find((c) => c.id === id) || null;
+  }
+  async saveContract(contract) {
+    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");
+  }
+  async getActiveContracts(packageName, targetVersion) {
+    const all = await this.listContracts(packageName);
+    return all.filter((contract) => {
+      if (contract.introducedIn && semver3.valid(contract.introducedIn)) {
+        if (semver3.gt(contract.introducedIn, targetVersion)) {
+          return false;
+        }
+      }
+      if (contract.removedIn && semver3.valid(contract.removedIn)) {
+        if (semver3.lte(contract.removedIn, targetVersion)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+};
+
+// ../contracts/dist/packer.js
+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 { 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-"));
+    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");
+    await mkdir2(unpackedDir, { recursive: true });
+    await tar.x({
+      file: tarballPath,
+      cwd: unpackedDir,
+      strip: 1
+      // npm pack packages inside 'package/' directory
+    });
+    return {
+      packageName,
+      version,
+      tarballPath,
+      unpackedDir
+    };
+  }
+  async cleanup(packResult) {
+    try {
+      const parentDir = join3(packResult.unpackedDir, "..");
+      await rm(parentDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+
+// ../contracts/dist/runner.js
+import { mkdir as mkdir3, symlink, rm as rm2, writeFile as writeFile2, copyFile } from "fs/promises";
+import { join as join4, 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";
+var NodeTestAdapter = class {
+  options;
+  name = "node:test";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    const hasNodeTestScript = Object.values(scripts).some((s) => s.includes("node --test"));
+    const hasTestFiles = ctx.files.some((f) => f.endsWith(".test.js") || f.endsWith(".test.mjs") || f.endsWith(".test.ts") || f.endsWith(".test.cjs"));
+    if (hasNodeTestScript) {
+      return { supported: true, confidence: 0.95 };
+    }
+    if (hasTestFiles) {
+      return { supported: true, confidence: 0.7 };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const reporter = this.options.reporter || "tap";
+    const loaderArgs = this.options.loaderArgs || [];
+    const testFiles = ctx.testFiles && ctx.testFiles.length > 0 ? ctx.testFiles : [];
+    const command = [
+      "node",
+      ...loaderArgs,
+      "--test",
+      `--test-reporter=${reporter}`,
+      ...testFiles,
+      ...ctx.extraArgs || []
+    ];
+    return new Promise((resolve3) => {
+      const cleanEnv = {
+        ...process.env,
+        ...ctx.env,
+        ...ctx.isolatedNodeModulesPath ? { NODE_PATH: ctx.isolatedNodeModulesPath } : {}
+      };
+      for (const k of Object.keys(cleanEnv)) {
+        if (k.startsWith("NODE_TEST_")) {
+          delete cleanEnv[k];
+        }
+      }
+      const child = spawn(command[0], command.slice(1), {
+        cwd: ctx.packagePath,
+        env: cleanEnv,
+        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 success = code === 0;
+        const { suites, total, passed, failed, skipped, diagnostics } = this.parseOutput(stdout, stderr, success);
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs,
+          success,
+          suites,
+          diagnostics,
+          totalTests: total,
+          passedTests: passed,
+          failedTests: failed,
+          skippedTests: skipped
+        });
+      });
+      child.on("error", (err) => {
+        const durationMs = Date.now() - startTime;
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs,
+          success: false,
+          suites: [],
+          diagnostics: [{ severity: "error", message: err.message, stack: err.stack }],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+  parseOutput(stdout, stderr, overallSuccess) {
+    const lines = stdout.split("\n");
+    const testCases = [];
+    const diagnostics = [];
+    let currentFailure;
+    let currentTestName = "";
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("ok ") || line.startsWith("not ok ")) {
+        const isOk = line.startsWith("ok ");
+        const isSkipped = line.includes("# SKIP") || line.includes("# skip");
+        const isTodo = line.includes("# TODO") || line.includes("# todo");
+        let name = line.replace(/^(ok|not ok)\s+\d+\s+-?\s*/, "");
+        const timeMatch = name.match(/# time=([\d.]+)ms/);
+        const durationMs = timeMatch ? parseFloat(timeMatch[1]) : void 0;
+        name = name.replace(/#.*$/, "").trim();
+        let status = "passed";
+        if (isSkipped) {
+          status = "skipped";
+        } else if (isTodo) {
+          status = "todo";
+        } else if (!isOk) {
+          status = "failed";
+        }
+        const tc = {
+          name: name || `Test #${testCases.length + 1}`,
+          status,
+          durationMs
+        };
+        if (!isOk) {
+          const failureLines = [];
+          let j = i + 1;
+          while (j < lines.length && (lines[j].startsWith("  ") || lines[j].startsWith("---"))) {
+            failureLines.push(lines[j]);
+            j++;
+          }
+          if (failureLines.length > 0) {
+            tc.failure = {
+              message: failureLines.join("\n").trim()
+            };
+          } else {
+            tc.failure = {
+              message: "Test failed"
+            };
+          }
+        }
+        testCases.push(tc);
+      }
+    }
+    if (stderr.trim()) {
+      diagnostics.push({
+        severity: "warning",
+        message: stderr.trim()
+      });
+    }
+    if (testCases.length === 0) {
+      testCases.push({
+        name: "node:test execution",
+        status: overallSuccess ? "passed" : "failed",
+        failure: overallSuccess ? void 0 : {
+          message: stderr || stdout || "Execution failed"
+        }
+      });
+    }
+    const passed = testCases.filter((t) => t.status === "passed").length;
+    const failed = testCases.filter((t) => t.status === "failed").length;
+    const skipped = testCases.filter((t) => t.status === "skipped" || t.status === "todo").length;
+    const total = testCases.length;
+    const suite = {
+      name: "node:test",
+      status: failed === 0 && overallSuccess ? "passed" : "failed",
+      tests: testCases
+    };
+    return {
+      suites: [suite],
+      total,
+      passed,
+      failed,
+      skipped,
+      diagnostics
+    };
+  }
+};
+
+// ../contracts/dist/runner.js
+var ContractRunner = class {
+  testAdapter;
+  constructor(testAdapter = new NodeTestAdapter()) {
+    this.testAdapter = testAdapter;
+  }
+  async runContract(contract, candidate) {
+    const startTime = Date.now();
+    const consumerEnvDir = await mkdtemp2(join4(tmpdir2(), "verelease-consumer-"));
+    const nodeModulesDir = join4(consumerEnvDir, "node_modules");
+    try {
+      await writeFile2(join4(consumerEnvDir, "package.json"), JSON.stringify({ name: "consumer-fixture", type: "module" }, null, 2), "utf8");
+      let targetPkgLink = join4(nodeModulesDir, candidate.packageName);
+      if (candidate.packageName.startsWith("@")) {
+        const [scope, pkgName] = candidate.packageName.split("/");
+        const scopeDir = join4(nodeModulesDir, scope);
+        await mkdir3(scopeDir, { recursive: true });
+        targetPkgLink = join4(scopeDir, pkgName);
+      } else {
+        await mkdir3(nodeModulesDir, { recursive: true });
+      }
+      await symlink(candidate.unpackedDir, targetPkgLink, "junction");
+      const isolatedTestName = basename(contract.testFile);
+      const isolatedTestPath = join4(consumerEnvDir, isolatedTestName);
+      await copyFile(contract.testFile, isolatedTestPath);
+      const testRun = await this.testAdapter.run({
+        packagePath: consumerEnvDir,
+        targetPackageName: candidate.packageName,
+        testFiles: [isolatedTestPath],
+        isolatedNodeModulesPath: nodeModulesDir
+      });
+      const durationMs = Date.now() - startTime;
+      const failed = !testRun.success || testRun.failedTests > 0;
+      let evidence;
+      if (failed) {
+        const failureDetails = testRun.suites[0]?.tests.find((t) => t.status === "failed")?.failure?.message || "Historical contract failed";
+        evidence = {
+          id: `contract.fail:${contract.id}`,
+          package: candidate.packageName,
+          source: "contract",
+          severity: contract.severity || "major",
+          confidence: 0.98,
+          title: `Historical Contract Failed: ${contract.title}`,
+          description: `Contract "${contract.id}" (${contract.category}) failed against candidate package.
+Details: ${failureDetails}`,
+          files: [contract.testFile],
+          contracts: [contract.id],
+          metadata: {
+            contractId: contract.id,
+            introducedIn: contract.introducedIn,
+            category: contract.category,
+            diagnostics: testRun.diagnostics
+          }
+        };
+      }
+      return {
+        contract,
+        status: failed ? "failed" : "passed",
+        testResult: testRun.suites[0]?.tests[0],
+        evidence,
+        durationMs
+      };
+    } finally {
+      try {
+        await rm2(consumerEnvDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+};
+
+// ../contracts/dist/analyzer.js
+var ContractCompatibilityAnalyzer = class {
+  store;
+  runner;
+  packer;
+  name = "contract-compatibility-analyzer";
+  constructor(store, runner = new ContractRunner(), packer = new CandidatePacker()) {
+    this.store = store;
+    this.runner = runner;
+    this.packer = packer;
+  }
+  async analyze(context) {
+    const activeContracts = await this.store.getActiveContracts(context.packageName, context.currentVersion);
+    if (activeContracts.length === 0) {
+      return [];
+    }
+    const packResult = await this.packer.pack(context.packagePath, context.packageName, context.currentVersion);
+    const evidenceList = [];
+    try {
+      for (const contract of activeContracts) {
+        const result = await this.runner.runContract(contract, packResult);
+        if (result.evidence) {
+          evidenceList.push(result.evidence);
+        }
+      }
+    } finally {
+      await this.packer.cleanup(packResult);
+    }
+    return evidenceList;
+  }
+};
+
+// ../api-diff/dist/extractor.js
+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);
+    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] = {
+          kind: "function",
+          name: fnName,
+          parameters,
+          returnType: node.type ? node.type.getText(sourceFile) : "void",
+          isAsync: !!modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+        };
+      } else if (ts.isVariableStatement(node) && isExported) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) {
+            const varName = decl.name.text;
+            exports[varName] = {
+              kind: "variable",
+              name: varName,
+              typeString: decl.type ? decl.type.getText(sourceFile) : "any"
+            };
+          }
+        }
+      } else if (ts.isClassDeclaration(node) && node.name && isExported) {
+        const className = node.name.text;
+        const methods = {};
+        const properties = {};
+        for (const member of node.members) {
+          if (ts.isMethodDeclaration(member) && member.name) {
+            const methodName = member.name.getText(sourceFile);
+            const memberModifiers = ts.canHaveModifiers(member) ? ts.getModifiers(member) : void 0;
+            methods[methodName] = {
+              kind: "function",
+              name: methodName,
+              parameters: member.parameters.map((p) => ({
+                name: p.name.getText(sourceFile),
+                isOptional: !!p.questionToken || !!p.initializer,
+                typeString: p.type ? p.type.getText(sourceFile) : "any"
+              })),
+              returnType: member.type ? member.type.getText(sourceFile) : "void",
+              isAsync: !!memberModifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+            };
+          } else if (ts.isPropertyDeclaration(member) && member.name) {
+            const propName = member.name.getText(sourceFile);
+            properties[propName] = {
+              name: propName,
+              isOptional: !!member.questionToken,
+              typeString: member.type ? member.type.getText(sourceFile) : "any"
+            };
+          }
+        }
+        exports[className] = {
+          kind: "class",
+          name: className,
+          methods,
+          properties
+        };
+      } else if (ts.isInterfaceDeclaration(node) && node.name && isExported) {
+        const ifaceName = node.name.text;
+        const properties = {};
+        for (const member of node.members) {
+          if (ts.isPropertySignature(member) && member.name) {
+            const propName = member.name.getText(sourceFile);
+            properties[propName] = {
+              name: propName,
+              isOptional: !!member.questionToken,
+              typeString: member.type ? member.type.getText(sourceFile) : "any"
+            };
+          }
+        }
+        exports[ifaceName] = {
+          kind: "interface",
+          name: ifaceName,
+          properties
+        };
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return { exports };
+  }
+};
+
+// ../api-diff/dist/diff.js
+var ApiDiffEngine = class {
+  diff(packageName, baseline, candidate) {
+    const evidence = [];
+    const baselineExports = baseline.exports;
+    const candidateExports = candidate.exports;
+    for (const [name, baseSym] of Object.entries(baselineExports)) {
+      if (!candidateExports[name]) {
+        evidence.push({
+          id: `api.export.removed:${name}`,
+          package: packageName,
+          source: "api",
+          severity: "major",
+          confidence: 1,
+          title: `Public export removed: ${name}`,
+          description: `Exported ${baseSym.kind} "${name}" was removed from the public API surface.`
+        });
+        continue;
+      }
+      const candSym = candidateExports[name];
+      if (baseSym.kind !== candSym.kind) {
+        evidence.push({
+          id: `api.export.kindChanged:${name}`,
+          package: packageName,
+          source: "api",
+          severity: "major",
+          confidence: 1,
+          title: `Public export kind changed: ${name}`,
+          description: `Export "${name}" changed from ${baseSym.kind} to ${candSym.kind}.`
+        });
+        continue;
+      }
+      if (baseSym.kind === "function" && candSym.kind === "function") {
+        this.diffFunction(packageName, name, baseSym, candSym, evidence);
+      } else if (baseSym.kind === "interface" && candSym.kind === "interface") {
+        this.diffInterface(packageName, name, baseSym, candSym, evidence);
+      }
+    }
+    for (const [name, candSym] of Object.entries(candidateExports)) {
+      if (!baselineExports[name]) {
+        evidence.push({
+          id: `api.export.added:${name}`,
+          package: packageName,
+          source: "api",
+          severity: "minor",
+          confidence: 0.95,
+          title: `New public export added: ${name}`,
+          description: `New ${candSym.kind} "${name}" added to the public API surface.`
+        });
+      }
+    }
+    return evidence;
+  }
+  diffFunction(packageName, fnName, baseFn, candFn, evidence) {
+    const baseParams = baseFn.parameters;
+    const candParams = candFn.parameters;
+    if (candParams.length < baseParams.length) {
+      evidence.push({
+        id: `api.function.paramRemoved:${fnName}`,
+        package: packageName,
+        source: "api",
+        severity: "major",
+        confidence: 0.98,
+        title: `Parameter removed in function: ${fnName}`,
+        description: `Function "${fnName}" parameter count decreased from ${baseParams.length} to ${candParams.length}.`
+      });
+      return;
+    }
+    for (let i = baseParams.length; i < candParams.length; i++) {
+      const addedParam = candParams[i];
+      if (!addedParam.isOptional) {
+        evidence.push({
+          id: `api.function.requiredParamAdded:${fnName}:${addedParam.name}`,
+          package: packageName,
+          source: "api",
+          severity: "major",
+          confidence: 0.98,
+          title: `Required parameter added to function: ${fnName}`,
+          description: `Function "${fnName}" added a required parameter "${addedParam.name}". Existing calls with fewer arguments will fail.`
+        });
+      } else {
+        evidence.push({
+          id: `api.function.optionalParamAdded:${fnName}:${addedParam.name}`,
+          package: packageName,
+          source: "api",
+          severity: "minor",
+          confidence: 0.95,
+          title: `Optional parameter added to function: ${fnName}`,
+          description: `Function "${fnName}" added an optional parameter "${addedParam.name}".`
+        });
+      }
+    }
+    for (let i = 0; i < baseParams.length; i++) {
+      const baseP = baseParams[i];
+      const candP = candParams[i];
+      if (baseP.isOptional && !candP.isOptional) {
+        evidence.push({
+          id: `api.function.paramBecameRequired:${fnName}:${candP.name}`,
+          package: packageName,
+          source: "api",
+          severity: "major",
+          confidence: 0.98,
+          title: `Parameter became required in function: ${fnName}`,
+          description: `Parameter "${candP.name}" of function "${fnName}" was optional and is now required.`
+        });
+      } else if (baseP.typeString !== candP.typeString && baseP.typeString !== "any" && candP.typeString !== "any") {
+        evidence.push({
+          id: `api.function.paramTypeChanged:${fnName}:${candP.name}`,
+          package: packageName,
+          source: "api",
+          severity: "major",
+          confidence: 0.9,
+          title: `Parameter type changed in function: ${fnName}`,
+          description: `Parameter "${candP.name}" in function "${fnName}" changed type from "${baseP.typeString}" to "${candP.typeString}".`
+        });
+      }
+    }
+  }
+  diffInterface(packageName, ifaceName, baseIface, candIface, evidence) {
+    for (const [propName, prop] of Object.entries(baseIface.properties)) {
+      if (!candIface.properties[propName]) {
+        evidence.push({
+          id: `api.interface.propertyRemoved:${ifaceName}:${propName}`,
+          package: packageName,
+          source: "types",
+          severity: "major",
+          confidence: 0.95,
+          title: `Property removed from interface: ${ifaceName}.${propName}`,
+          description: `Interface "${ifaceName}" removed property "${propName}".`
+        });
+      }
+    }
+    for (const [propName, prop] of Object.entries(candIface.properties)) {
+      if (!baseIface.properties[propName]) {
+        if (!prop.isOptional) {
+          evidence.push({
+            id: `api.interface.requiredPropertyAdded:${ifaceName}:${propName}`,
+            package: packageName,
+            source: "types",
+            severity: "major",
+            confidence: 0.95,
+            title: `Required property added to interface: ${ifaceName}.${propName}`,
+            description: `Interface "${ifaceName}" added required property "${propName}". Consumers implementing this interface will fail.`
+          });
+        } else {
+          evidence.push({
+            id: `api.interface.optionalPropertyAdded:${ifaceName}:${propName}`,
+            package: packageName,
+            source: "types",
+            severity: "minor",
+            confidence: 0.9,
+            title: `Optional property added to interface: ${ifaceName}.${propName}`,
+            description: `Interface "${ifaceName}" added optional property "${propName}".`
+          });
+        }
+      }
+    }
+  }
+};
+
+// ../api-diff/dist/analyzer.js
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { join as join5 } from "path";
+async function fileExists2(path) {
+  try {
+    const s = await stat2(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+var ApiDiffAnalyzer = class {
+  extractor;
+  engine;
+  name = "api-diff-analyzer";
+  constructor(extractor = new ApiExtractor(), engine = new ApiDiffEngine()) {
+    this.extractor = extractor;
+    this.engine = engine;
+  }
+  async analyze(context) {
+    const candidateEntrypoint = await this.findEntrypoint(context.packagePath);
+    if (!candidateEntrypoint) {
+      return [];
+    }
+    const candidateSource = await readFile3(candidateEntrypoint, "utf8");
+    const candidateSnapshot = this.extractor.extractFromSource(candidateSource, candidateEntrypoint);
+    let baselineSnapshot;
+    if (context.baselinePath && await fileExists2(context.baselinePath)) {
+      const baseSource = await readFile3(context.baselinePath, "utf8");
+      if (context.baselinePath.endsWith(".json")) {
+        baselineSnapshot = JSON.parse(baseSource);
+      } else {
+        baselineSnapshot = this.extractor.extractFromSource(baseSource, context.baselinePath);
+      }
+    }
+    if (!baselineSnapshot) {
+      return [];
+    }
+    return this.engine.diff(context.packageName, baselineSnapshot, candidateSnapshot);
+  }
+  async findEntrypoint(pkgDir) {
+    const candidates = [
+      join5(pkgDir, "src", "index.ts"),
+      join5(pkgDir, "src", "index.js"),
+      join5(pkgDir, "index.ts"),
+      join5(pkgDir, "index.js"),
+      join5(pkgDir, "dist", "index.d.ts")
+    ];
+    for (const c of candidates) {
+      if (await fileExists2(c)) {
+        return c;
+      }
+    }
+    return null;
+  }
+};
+
+// ../manifest/dist/mutator.js
+import { readFile as readFile4, writeFile as writeFile3, stat as stat3 } from "fs/promises";
+import { join as join6 } from "path";
+async function fileExists3(path) {
+  try {
+    const s = await stat3(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 = join6(pkgPlan.directory, "package.json");
+        const jsrJson = join6(pkgPlan.directory, "jsr.json");
+        const denoJson = join6(pkgPlan.directory, "deno.json");
+        if (await fileExists3(pkgJson))
+          filesToTouch.add(pkgJson);
+        if (await fileExists3(jsrJson))
+          filesToTouch.add(jsrJson);
+        if (await fileExists3(denoJson))
+          filesToTouch.add(denoJson);
+      }
+      for (const update of pkgPlan.dependentUpdates) {
+        const depPkgPlan = plan.packages.find((p) => p.name === update.dependentName);
+        if (depPkgPlan) {
+          const depPkgJson = join6(depPkgPlan.directory, "package.json");
+          if (await fileExists3(depPkgJson))
+            filesToTouch.add(depPkgJson);
+        }
+      }
+    }
+    for (const filePath of filesToTouch) {
+      const originalContent = await readFile4(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
+          });
+        }
+      }
+      for (const pkgPlan of plan.packages) {
+        const pkgJsonPath = join6(pkgPlan.directory, "package.json");
+        if (filesToTouch.has(pkgJsonPath)) {
+          const content = await readFile4(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);
+        }
+        const jsrJsonPath = join6(pkgPlan.directory, "jsr.json");
+        if (filesToTouch.has(jsrJsonPath)) {
+          const content = await readFile4(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);
+        }
+        const denoJsonPath = join6(pkgPlan.directory, "deno.json");
+        if (filesToTouch.has(denoJsonPath)) {
+          const content = await readFile4(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);
+        }
+      }
+    } 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");
+        }
+      },
+      async commit() {
+      }
+    };
+    return transaction;
+  }
+};
+
+// ../manifest/dist/lockfile.js
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { stat as stat4 } from "fs/promises";
+import { join as join7 } from "path";
+var execFileAsync2 = promisify2(execFile2);
+async function fileExists4(path) {
+  try {
+    const s = await stat4(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+var PnpmLockfileAdapter = class {
+  packageManager = "pnpm";
+  async regenerateLockfile(rootDirectory) {
+    const start = Date.now();
+    try {
+      const { stdout, stderr } = await execFileAsync2("pnpm", ["install", "--lockfile-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 NpmLockfileAdapter = class {
+  packageManager = "npm";
+  async regenerateLockfile(rootDirectory) {
+    const start = Date.now();
+    try {
+      const { stdout, stderr } = await execFileAsync2("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 AutoLockfileAdapter = class {
+  packageManager = "npm";
+  async regenerateLockfile(rootDirectory) {
+    if (await fileExists4(join7(rootDirectory, "pnpm-lock.yaml"))) {
+      this.packageManager = "pnpm";
+      return new PnpmLockfileAdapter().regenerateLockfile(rootDirectory);
+    }
+    if (await fileExists4(join7(rootDirectory, "package-lock.json"))) {
+      this.packageManager = "npm";
+      return new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
+    }
+    return new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
+  }
+};
+
+// ../publisher-npm/dist/publisher.js
+import { execFile as execFile3, spawn as spawn2 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      execFile3("open", [url]);
+    } else if (platform === "win32") {
+      execFile3("cmd", ["/c", "start", '""', url]);
+    } else {
+      execFile3("xdg-open", [url]);
+    }
+  } catch {
+  }
+}
+async function pollForWebAuthToken(doneUrl, timeoutMs = 9e4) {
+  const start = Date.now();
+  const pollIntervalMs = 1500;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = 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;
+        }
+      }
+    } catch {
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
+  }
+  return null;
+}
+var NpmPublishProvider = class {
+  options;
+  name = "npm";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  getDistTag(channel) {
+    if (!channel || channel === "stable") {
+      return "latest";
+    }
+    return channel;
+  }
+  async prepare(ctx) {
+    try {
+      await execFileAsync3("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)}`);
+    }
+  }
+  async publish(ctx) {
+    const startTime = Date.now();
+    const distTag = ctx.tag || this.getDistTag(ctx.packagePlan.channel);
+    const args = ["publish", "--tag", distTag];
+    if (ctx.dryRun) {
+      args.push("--dry-run");
+    }
+    const access = ctx.access || this.options.defaultAccess || "public";
+    args.push("--access", access);
+    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) {
+      args.push("--provenance");
+    }
+    if (ctx.registryUrl) {
+      args.push("--registry", ctx.registryUrl);
+    }
+    if (ctx.extraArgs) {
+      args.push(...ctx.extraArgs);
+    }
+    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:`);
+      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.
+`);
+      return new Promise((resolve3) => {
+        const child = spawn2("npm", args, {
+          cwd: ctx.packagePlan.directory,
+          stdio: "inherit"
+        });
+        child.on("close", (code) => {
+          if (code === 0) {
+            resolve3({
+              provider: this.name,
+              packageName: ctx.packagePlan.name,
+              version: ctx.packagePlan.proposedVersion,
+              published: true,
+              dryRun: ctx.dryRun,
+              distTag,
+              durationMs: Date.now() - startTime,
+              output: "Interactive publish completed successfully."
+            });
+          } else {
+            resolve3({
+              provider: this.name,
+              packageName: ctx.packagePlan.name,
+              version: ctx.packagePlan.proposedVersion,
+              published: false,
+              dryRun: ctx.dryRun,
+              distTag,
+              durationMs: Date.now() - startTime,
+              output: "",
+              error: `npm publish exited with code ${code} (2FA authentication failed, timed out, or was aborted)`
+            });
+          }
+        });
+        child.on("error", (err) => {
+          resolve3({
+            provider: this.name,
+            packageName: ctx.packagePlan.name,
+            version: ctx.packagePlan.proposedVersion,
+            published: false,
+            dryRun: ctx.dryRun,
+            distTag,
+            durationMs: Date.now() - startTime,
+            output: "",
+            error: err.message
+          });
+        });
+      });
+    }
+    try {
+      const { stdout, stderr } = await execFileAsync3("npm", args, {
+        cwd: ctx.packagePlan.directory
+      });
+      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
+`);
+        }
+      }
+      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)
+      };
+    }
+  }
+  async getPublishedVersions(packageName) {
+    try {
+      const { stdout } = await execFileAsync3("npm", ["view", packageName, "versions", "--json"]);
+      const parsed = JSON.parse(stdout.trim());
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+      if (typeof parsed === "string") {
+        return [parsed];
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// ../config/dist/config.js
+import { stat as stat5 } from "fs/promises";
+import { join as join8 } from "path";
+import { pathToFileURL } from "url";
+async function fileExists5(path) {
+  try {
+    const s = await stat5(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function loadConfig(rootDir) {
+  const candidateNames = [
+    "verelease.config.ts",
+    "verelease.config.mts",
+    "verelease.config.js",
+    "verelease.config.mjs",
+    "autoversion.config.ts",
+    "autoversion.config.mts",
+    "autoversion.config.js",
+    "autoversion.config.mjs"
+  ];
+  for (const name of candidateNames) {
+    const fullPath = join8(rootDir, name);
+    if (await fileExists5(fullPath)) {
+      try {
+        const fileUrl = pathToFileURL(fullPath).href;
+        const mod = await import(fileUrl);
+        return mod.default || mod;
+      } catch {
+      }
+    }
+  }
+  return {
+    workspace: { mode: "auto" },
+    versioning: { strategy: "independent" },
+    contracts: { directory: ".verelease/contracts" },
+    releases: { channels: ["stable", "alpha", "beta", "rc"] },
+    publish: [{ provider: "npm", access: "public" }]
+  };
+}
+
+// ../ai/dist/schemas.js
+import { z } from "zod";
+var ChangelogSchema = z.object({
+  breakingChanges: z.array(z.string()).default([]),
+  added: z.array(z.string()).default([]),
+  fixed: z.array(z.string()).default([]),
+  migrationSummary: z.string().optional()
+});
+var MigrationGuideSchema = z.object({
+  summary: z.string(),
+  breakingChanges: z.array(z.object({
+    title: z.string(),
+    explanation: z.string(),
+    before: z.string().optional(),
+    after: z.string().optional(),
+    automatable: z.boolean().default(false)
+  })).default([]),
+  manualSteps: z.array(z.string()).default([]),
+  warnings: z.array(z.string()).default([])
+});
+var MigrationScriptSchema = z.object({
+  description: z.string(),
+  scriptContent: z.string(),
+  fileExtension: z.enum(["ts", "js"]).default("js")
+});
+
+// ../ai/dist/changelog.js
+function renderChangelogMarkdown(version, date, data) {
+  const parts = [`# ${version} (${date})`, ""];
+  if (data.breakingChanges.length > 0) {
+    parts.push("## \u26A0\uFE0F Breaking Changes");
+    for (const item of data.breakingChanges) {
+      parts.push(`- ${item}`);
+    }
+    parts.push("");
+  }
+  if (data.added.length > 0) {
+    parts.push("## \u2728 Added");
+    for (const item of data.added) {
+      parts.push(`- ${item}`);
+    }
+    parts.push("");
+  }
+  if (data.fixed.length > 0) {
+    parts.push("## \u{1F41B} Fixed");
+    for (const item of data.fixed) {
+      parts.push(`- ${item}`);
+    }
+    parts.push("");
+  }
+  if (data.migrationSummary) {
+    parts.push("## \u{1F4D6} Migration");
+    parts.push(data.migrationSummary);
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function synthesizeChangelogFromEvidence(input) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const breaking = [];
+  const added = [];
+  const fixed = [];
+  for (const ev of input.evidence) {
+    if (ev.severity === "major") {
+      breaking.push(`${ev.title}: ${ev.description}`);
+    } else if (ev.severity === "minor") {
+      added.push(`${ev.title}: ${ev.description}`);
+    } else if (ev.severity === "patch") {
+      fixed.push(`${ev.title}: ${ev.description}`);
+    }
+  }
+  if (input.commits) {
+    for (const commit of input.commits) {
+      const msg = commit.message.toLowerCase();
+      if (msg.startsWith("feat")) {
+        added.push(commit.message);
+      } else if (msg.startsWith("fix")) {
+        fixed.push(commit.message);
+      }
+    }
+  }
+  const structured = {
+    breakingChanges: Array.from(new Set(breaking)),
+    added: Array.from(new Set(added)),
+    fixed: Array.from(new Set(fixed)),
+    migrationSummary: breaking.length > 0 ? `See the generated migration guide for upgrading from ${input.previousVersion} to ${input.newVersion}.` : void 0
+  };
+  const markdown = renderChangelogMarkdown(input.newVersion, date, structured);
+  return {
+    version: input.newVersion,
+    date,
+    markdown,
+    structured
+  };
+}
+
+// ../ai/dist/migration-guide.js
+function renderMigrationGuideMarkdown(packageName, fromVersion, toVersion, data) {
+  const parts = [
+    `# Migrating ${packageName} from ${fromVersion} to ${toVersion}`,
+    "",
+    data.summary,
+    ""
+  ];
+  if (data.breakingChanges.length > 0) {
+    parts.push("## Breaking Changes");
+    parts.push("");
+    for (const change of data.breakingChanges) {
+      parts.push(`### ${change.title}`);
+      parts.push("");
+      parts.push(change.explanation);
+      parts.push("");
+      if (change.before) {
+        parts.push("Before:");
+        parts.push("```ts");
+        parts.push(change.before.trim());
+        parts.push("```");
+        parts.push("");
+      }
+      if (change.after) {
+        parts.push("After:");
+        parts.push("```ts");
+        parts.push(change.after.trim());
+        parts.push("```");
+        parts.push("");
+      }
+      if (change.automatable) {
+        parts.push("> \u{1F4A1} **Note:** This breaking change is machine-transformable via Verelease codemod.");
+        parts.push("");
+      }
+    }
+  }
+  if (data.manualSteps.length > 0) {
+    parts.push("## Manual Steps");
+    parts.push("");
+    for (const step of data.manualSteps) {
+      parts.push(`1. ${step}`);
+    }
+    parts.push("");
+  }
+  if (data.warnings.length > 0) {
+    parts.push("## Warnings");
+    parts.push("");
+    for (const warning of data.warnings) {
+      parts.push(`- \u26A0\uFE0F ${warning}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function synthesizeMigrationGuideFromEvidence(input) {
+  const breakingItems = [];
+  for (const ev of input.breakingChanges) {
+    let before;
+    let after;
+    if (ev.title.includes("createRouter")) {
+      before = `import { createRouter } from "${input.packageName}";
+const router = createRouter({ routes });`;
+      after = `import { createRouter } from "${input.packageName}";
+const router = createRouter(routes);`;
+    }
+    breakingItems.push({
+      title: ev.title,
+      explanation: ev.description,
+      before,
+      after,
+      automatable: !!before
+    });
+  }
+  const structured = {
+    summary: `This guide provides steps for upgrading ${input.packageName} from version ${input.previousVersion} to ${input.newVersion}.`,
+    breakingChanges: breakingItems,
+    manualSteps: [
+      `Update dependency range for ${input.packageName} to ^${input.newVersion} in package.json`,
+      "Run your test suite to verify compatibility"
+    ],
+    warnings: [
+      "Review all breaking changes above before deploying to production."
+    ]
+  };
+  const markdown = renderMigrationGuideMarkdown(input.packageName, input.previousVersion, input.newVersion, structured);
+  return {
+    packageName: input.packageName,
+    fromVersion: input.previousVersion,
+    toVersion: input.newVersion,
+    markdown,
+    structured
+  };
+}
+
+// ../ai/dist/migration-script.js
+function synthesizeMigrationScriptFromEvidence(input) {
+  const scriptContent = `
+import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+function walkAndTransform(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
+      walkAndTransform(fullPath);
+    } else if (entry.isFile() && (/\\.(js|ts|mjs|jsx|tsx)$/).test(entry.name)) {
+      let content = readFileSync(fullPath, "utf8");
+      let changed = false;
+
+      // Transform createRouter({ routes: ... }) -> createRouter(...)
+      const regex = /createRouter\\s*\\(\\s*\\{\\s*routes:\\s*([^}]+)\\s*\\}\\s*\\)/g;
+      if (regex.test(content)) {
+        content = content.replace(regex, "createRouter($1)");
+        changed = true;
+      }
+
+      if (changed) {
+        writeFileSync(fullPath, content, "utf8");
+        console.log("Transformed:", fullPath);
+      }
+    }
+  }
+}
+
+const targetDir = process.argv[2] || process.cwd();
+walkAndTransform(targetDir);
+`;
+  return {
+    id: `codemod-${input.packageName.replace(/[^a-zA-Z0-9]/g, "_")}-${input.fromVersion}-to-${input.toVersion}`,
+    packageName: input.packageName,
+    fromVersion: input.fromVersion,
+    toVersion: input.toVersion,
+    scriptContent: scriptContent.trim(),
+    fileExtension: "js",
+    description: `Automated codemod to migrate ${input.packageName} from ${input.fromVersion} to ${input.toVersion}`
+  };
+}
+
+// ../ai/dist/validation.js
+import { cp, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile4, mkdir as mkdir4, symlink as symlink2, readdir as readdir3 } from "fs/promises";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { join as join9 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import * as tar2 from "tar";
+var execFileAsync4 = promisify4(execFile4);
+
+// ../ai/dist/provider.js
+var TanStackReleaseAI = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async generateChangelog(input) {
+    if (this.client?.generateStructured) {
+      try {
+        const prompt = `Generate a changelog for package ${input.packageName} from version ${input.previousVersion} to ${input.newVersion} based on the following evidence:
+${JSON.stringify(input.evidence, null, 2)}`;
+        const structured = await this.client.generateStructured({
+          schema: ChangelogSchema,
+          prompt
+        });
+        const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        const markdown = renderChangelogMarkdown(input.newVersion, date, structured);
+        return {
+          version: input.newVersion,
+          date,
+          markdown,
+          structured
+        };
+      } catch {
+      }
+    }
+    return synthesizeChangelogFromEvidence(input);
+  }
+  async generateMigrationGuide(input) {
+    if (this.client?.generateStructured) {
+      try {
+        const prompt = `Generate a migration guide for upgrading package ${input.packageName} from ${input.previousVersion} to ${input.newVersion} based on breaking changes:
+${JSON.stringify(input.breakingChanges, null, 2)}`;
+        const structured = await this.client.generateStructured({
+          schema: MigrationGuideSchema,
+          prompt
+        });
+        const markdown = renderMigrationGuideMarkdown(input.packageName, input.previousVersion, input.newVersion, structured);
+        return {
+          packageName: input.packageName,
+          fromVersion: input.previousVersion,
+          toVersion: input.newVersion,
+          markdown,
+          structured
+        };
+      } catch {
+      }
+    }
+    return synthesizeMigrationGuideFromEvidence(input);
+  }
+  async generateMigrationScript(input) {
+    return synthesizeMigrationScriptFromEvidence(input);
+  }
+};
+
+// ../git/dist/git.js
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execFileAsync5 = promisify5(execFile5);
+var GitManager = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  formatTagName(options) {
+    if (options.customFormat) {
+      return options.customFormat(options.packageName, options.version);
+    }
+    if (options.strategy === "fixed") {
+      return `v${options.version}`;
+    }
+    return `${options.packageName}@${options.version}`;
+  }
+  async isClean() {
+    const { stdout } = await execFileAsync5("git", ["status", "--porcelain"], {
+      cwd: this.cwd
+    });
+    return stdout.trim().length === 0;
+  }
+  async getHeadCommit() {
+    const { stdout } = await execFileAsync5("git", ["rev-parse", "HEAD"], {
+      cwd: this.cwd
+    });
+    return stdout.trim();
+  }
+  async createTag(tagName, message) {
+    const args = ["tag", "-a", tagName, "-m", message || `Release ${tagName}`];
+    await execFileAsync5("git", args, { cwd: this.cwd });
+  }
+  async createReleaseCommit(files, message = "chore(release): publish") {
+    if (files.length > 0) {
+      await execFileAsync5("git", ["add", ...files], { cwd: this.cwd });
+    } else {
+      await execFileAsync5("git", ["add", "-A"], { cwd: this.cwd });
+    }
+    await execFileAsync5("git", ["commit", "-m", message], { cwd: this.cwd });
+    return this.getHeadCommit();
+  }
+};
+
+// src/cli.ts
+import semver4 from "semver";
+var VereleaseCli = class {
+  cwd;
+  constructor(options = {}) {
+    this.cwd = resolve2(options.cwd || process.cwd());
+  }
+  async createPlan(options = {}) {
+    const config = await loadConfig(this.cwd);
+    const resolver = new DefaultWorkspaceResolver();
+    const discovery = await resolver.resolve(this.cwd);
+    const contractStore = new FileContractStore(
+      join10(this.cwd, config.contracts?.directory || ".verelease/contracts")
+    );
+    const contractAnalyzer = new ContractCompatibilityAnalyzer(contractStore);
+    const apiDiffAnalyzer = new ApiDiffAnalyzer();
+    const semverEngine = new DefaultSemVerDecisionEngine();
+    const npmPublisher = new NpmPublishProvider();
+    const evidenceMap = /* @__PURE__ */ new Map();
+    const initialBumps = /* @__PURE__ */ new Map();
+    for (const pkg of discovery.packages) {
+      const evidence = [];
+      try {
+        const contractEv = await contractAnalyzer.analyze({
+          packageName: pkg.name,
+          packagePath: pkg.directory,
+          currentVersion: pkg.version
+        });
+        evidence.push(...contractEv);
+      } catch {
+      }
+      try {
+        const apiEv = await apiDiffAnalyzer.analyze({
+          packageName: pkg.name,
+          packagePath: pkg.directory,
+          currentVersion: pkg.version
+        });
+        evidence.push(...apiEv);
+      } catch {
+      }
+      evidenceMap.set(pkg.name, evidence);
+      const decision = semverEngine.evaluate(
+        pkg.name,
+        pkg.version,
+        evidence,
+        config.versioning,
+        options.channel || "stable"
+      );
+      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;
+        } else {
+          proposedVersion = semver4.inc(pkg.version, forced) || pkg.version;
+        }
+        reasons.push(`Bump manually requested (${forced}) for channel ${channel}`);
+      }
+      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 nextCandidate = proposedVersion;
+            if (channel !== "stable") {
+              const baseBump = bump === "none" ? "patch" : bump;
+              const parsed = semver4.parse(pkg.version);
+              if (parsed.prerelease.length > 0 && parsed.prerelease[0] === channel) {
+                nextCandidate = semver4.inc(pkg.version, "prerelease", channel) || pkg.version;
+              } else {
+                nextCandidate = semver4.inc(pkg.version, `pre${baseBump}`, channel) || pkg.version;
+              }
+              while (publishedVersions.includes(nextCandidate)) {
+                nextCandidate = semver4.inc(nextCandidate, "prerelease", channel) || nextCandidate;
+              }
+            } else {
+              const baseBump = bump === "none" ? "patch" : bump;
+              nextCandidate = semver4.inc(pkg.version, baseBump) || pkg.version;
+              while (publishedVersions.includes(nextCandidate)) {
+                nextCandidate = semver4.inc(nextCandidate, "patch") || nextCandidate;
+              }
+            }
+            proposedVersion = nextCandidate;
+            bump = bump === "none" ? "patch" : bump;
+            reasons.push(`Automatically resolved next available registry version: ${proposedVersion}`);
+          }
+        } catch {
+        }
+      }
+      initialBumps.set(pkg.name, {
+        name: pkg.name,
+        currentVersion: pkg.version,
+        proposedVersion,
+        bump,
+        reasons
+      });
+    }
+    const propagator = new VersionPropagator(discovery.graph);
+    const { bumps: finalBumps, dependencyUpdates } = propagator.propagate(initialBumps);
+    const publishOrder = discovery.graph.getTopologicalOrder();
+    const packagePlans = [];
+    for (const pkgName of publishOrder) {
+      const pkg = discovery.packages.find((p) => p.name === pkgName);
+      if (!pkg) continue;
+      const bumpTarget = finalBumps.get(pkgName);
+      const evidence = evidenceMap.get(pkgName) || [];
+      const depUpdates = dependencyUpdates.get(pkgName) || [];
+      const decision = semverEngine.evaluate(
+        pkg.name,
+        pkg.version,
+        evidence,
+        config.versioning,
+        options.channel || "stable"
+      );
+      packagePlans.push({
+        name: pkg.name,
+        directory: pkg.directory,
+        currentVersion: pkg.version,
+        proposedVersion: bumpTarget.proposedVersion,
+        bump: bumpTarget.bump,
+        channel: options.channel || "stable",
+        evidence,
+        reasons: bumpTarget.reasons,
+        confidence: decision.confidence,
+        requiresApproval: decision.requiresApproval,
+        dependentUpdates: depUpdates.map((d) => ({
+          dependentName: pkgName,
+          dependencyName: d.dependencyName,
+          dependencyType: d.type,
+          previousRange: d.previousRange,
+          newRange: d.newRange
+        })),
+        filesToUpdate: [pkg.manifestPath],
+        publish: !pkg.isPrivate && bumpTarget.bump !== "none"
+      });
+    }
+    const plan = {
+      schemaVersion: 1,
+      id: `plan-${Date.now()}`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      rootDirectory: this.cwd,
+      channel: options.channel || "stable",
+      packages: packagePlans,
+      publishOrder,
+      summary: {
+        totalPackages: packagePlans.length,
+        bumpedPackages: packagePlans.filter((p) => p.bump !== "none").length,
+        majorBumps: packagePlans.filter((p) => p.bump === "major").length,
+        minorBumps: packagePlans.filter((p) => p.bump === "minor").length,
+        patchBumps: packagePlans.filter((p) => p.bump === "patch").length,
+        noneBumps: packagePlans.filter((p) => p.bump === "none").length
+      }
+    };
+    return { plan, evidenceMap };
+  }
+  async runPlanCommand(options = {}) {
+    const { plan } = await this.createPlan(options);
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+      return plan;
+    }
+    this.printPlan(plan);
+    try {
+      const verelDir = join10(this.cwd, ".verelease");
+      await mkdir5(verelDir, { recursive: true });
+      await writeFile5(
+        join10(verelDir, "release-plan.json"),
+        JSON.stringify(plan, null, 2),
+        "utf8"
+      );
+    } catch {
+    }
+    return plan;
+  }
+  async runReleaseCommand(options = {}) {
+    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.");
+      return;
+    }
+    const mutator = new TransactionalManifestMutator();
+    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 = join10(pkgPlan.directory, "CHANGELOG.md");
+        let existingChangelog = null;
+        try {
+          existingChangelog = await readFile5(changelogPath, "utf8");
+        } catch {
+          existingChangelog = null;
+        }
+        changelogBackups.set(changelogPath, existingChangelog);
+        await writeFile5(
+          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 = join10(pkgPlan.directory, "docs", "migrations");
+          await mkdir5(migrationsDir, { recursive: true });
+          const guidePath = join10(
+            migrationsDir,
+            `${pkgPlan.currentVersion.split(".")[0]}-to-${pkgPlan.proposedVersion.split(".")[0]}.md`
+          );
+          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({
+                packageName: pkgPlan.name,
+                version: pkgPlan.proposedVersion
+              });
+              await git.createTag(tagName);
+              console.log(`  \u2713 Created git tag: ${tagName}`);
+            }
+          }
+        } 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");
+          }
+          for (const [chPath, original] of changelogBackups) {
+            try {
+              if (original === null) {
+                await unlink(chPath);
+              } else {
+                await writeFile5(chPath, original, "utf8");
+              }
+            } catch {
+            }
+          }
+          console.log("  \u2713 Restored changelog files");
+          await lockfileAdapter.regenerateLockfile(this.cwd);
+          console.log("  \u2713 Synchronized lockfile\n");
+          process.exit(1);
+        }
+      }
+    }
+    console.log("\n\u{1F389} Release completed successfully!");
+  }
+  async runExplainCommand(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.`);
+      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}):`);
+    for (const ev of evidence) {
+      console.log(`  \u2022 [${ev.source.toUpperCase()}] (${ev.severity.toUpperCase()}) ${ev.title}`);
+      console.log(`    ${ev.description}
+`);
+    }
+    if (pkgPlan.reasons.length > 0) {
+      console.log("Decision reasons:");
+      for (const reason of pkgPlan.reasons) {
+        console.log(`  ${reason}`);
+      }
+    }
+  }
+  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
+`);
+    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"}`);
+      if (pkg.reasons.length > 0) {
+        console.log("  Reasons:");
+        for (const reason of pkg.reasons) {
+          console.log(`    ${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})`);
+        }
+      }
+      console.log("");
+    }
+  }
+};
+
+// src/bin.ts
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || "plan";
+  const options = {
+    dryRun: args.includes("--dry-run"),
+    json: args.includes("--json"),
+    tag: args.includes("--tag")
+  };
+  const channelIdx = args.indexOf("--channel");
+  if (channelIdx !== -1 && args[channelIdx + 1]) {
+    options.channel = args[channelIdx + 1];
+  }
+  const bumpIdx = args.indexOf("--bump");
+  if (bumpIdx !== -1 && args[bumpIdx + 1]) {
+    options.defaultBump = args[bumpIdx + 1];
+  }
+  const cwdIdx = args.indexOf("--cwd");
+  if (cwdIdx !== -1 && args[cwdIdx + 1]) {
+    options.cwd = args[cwdIdx + 1];
+  }
+  const otpIdx = args.indexOf("--otp");
+  if (otpIdx !== -1 && args[otpIdx + 1]) {
+    options.otp = args[otpIdx + 1];
+  }
+  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 "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(`Available commands: plan, release, version, explain`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`
+\u274C Error: ${err.message || String(err)}`);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=bin.js.map