@varlock/bumpy 0.0.2 → 1.1.0

package/dist/{publish-D_7RqEYL.mjs → publish-CGB4TIKD.mjs}

@@ -1,11 +1,11 @@
 import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
-import { a as loadConfig } from "./config-BkwIEaQg.mjs";
-import { n as detectWorkspaces } from "./package-manager-DcI5TdDE.mjs";
-import { n as discoverWorkspace } from "./workspace-CxEKakDm.mjs";
-import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
-import { n as runArgsAsync, o as tryRunArgs } from "./shell-Dj7JRD_q.mjs";
-import { a as pushWithTags, i as listTags, r as hasUncommittedChanges } from "./git-CGHVXXKw.mjs";
-import { t as publishPackages } from "./publish-pipeline-ChnqW8nR.mjs";
+import { a as loadConfig } from "./config-B-Qg3DZH.mjs";
+import { n as detectWorkspaces } from "./package-manager-Clsmr-9r.mjs";
+import { n as discoverWorkspace } from "./workspace-DWXlwcH4.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { r as runArgsAsync, s as tryRunArgs } from "./shell-CY7OD48z.mjs";
+import { a as hasUncommittedChanges, o as listTags, s as pushWithTags } from "./git-YDedMddc.mjs";
+import { t as publishPackages } from "./publish-pipeline-CXuqce1N.mjs";
 //#region src/core/github-release.ts
 /** Get the current HEAD commit SHA */
 function getHeadSha(rootDir) {
@@ -16,7 +16,7 @@ function getHeadSha(rootDir) {
 	], { cwd: rootDir });
 }
 /** Create individual GitHub releases for each published package */
-async function createIndividualReleases(releases, changesets, rootDir, opts = {}) {
+async function createIndividualReleases(releases, bumpFiles, rootDir, opts = {}) {
 	if (!isGhAvailable()) {
 		log.dim("  gh CLI not found — skipping GitHub releases");
 		return;
@@ -24,7 +24,7 @@ async function createIndividualReleases(releases, changesets, rootDir, opts = {}
 	const headSha = getHeadSha(rootDir);
 	for (const release of releases) {
 		const tag = `${release.name}@${release.newVersion}`;
-		const body = buildReleaseBody(release, changesets);
+		const body = buildReleaseBody(release, bumpFiles);
 		const title = `${release.name} v${release.newVersion}`;
 		if (opts.dryRun) {
 			log.dim(`  Would create GitHub release: ${title}`);
@@ -50,7 +50,7 @@ async function createIndividualReleases(releases, changesets, rootDir, opts = {}
 	}
 }
 /** Create a single aggregated GitHub release for all published packages */
-async function createAggregateRelease(releases, changesets, rootDir, opts = {}) {
+async function createAggregateRelease(releases, bumpFiles, rootDir, opts = {}) {
 	if (!isGhAvailable()) {
 		log.dim("  gh CLI not found — skipping GitHub release");
 		return;
@@ -58,7 +58,7 @@ async function createAggregateRelease(releases, changesets, rootDir, opts = {})
 	if (releases.length === 0) return;
 	const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
 	const { tag, title } = resolveAggregateTagAndTitle(date, listTags(`release-${date}*`, { cwd: rootDir }), opts.title);
-	const body = buildAggregateBody(releases, changesets);
+	const body = buildAggregateBody(releases, bumpFiles);
 	if (opts.dryRun) {
 		log.dim(`  Would create aggregate GitHub release: ${title}`);
 		log.dim(`  Tag: ${tag}`);
@@ -88,16 +88,16 @@ async function createAggregateRelease(releases, changesets, rootDir, opts = {})
 		log.warn(`Failed to create aggregate GitHub release: ${err instanceof Error ? err.message : err}`);
 	}
 }
-function buildReleaseBody(release, changesets) {
+function buildReleaseBody(release, bumpFiles) {
 	const lines = [];
-	const relevant = changesets.filter((cs) => release.changesets.includes(cs.id));
+	const relevant = bumpFiles.filter((bf) => release.bumpFiles.includes(bf.id));
 	if (relevant.length > 0) {
-		for (const cs of relevant) if (cs.summary) lines.push(`- ${cs.summary.split("\n")[0]}`);
+		for (const bf of relevant) if (bf.summary) lines.push(`- ${bf.summary.split("\n")[0]}`);
 	}
 	if (release.isDependencyBump && relevant.length === 0) lines.push("- Updated dependencies");
 	return lines.join("\n") || "No changelog entries.";
 }
-function buildAggregateBody(releases, changesets) {
+function buildAggregateBody(releases, bumpFiles) {
 	const lines = [];
 	const groups = [
 		["Major Changes", releases.filter((r) => r.type === "major")],
@@ -109,9 +109,9 @@ function buildAggregateBody(releases, changesets) {
 		lines.push(`## ${heading}\n`);
 		for (const release of group) {
 			lines.push(`### ${release.name} v${release.newVersion}\n`);
-			const relevant = changesets.filter((cs) => release.changesets.includes(cs.id));
+			const relevant = bumpFiles.filter((bf) => release.bumpFiles.includes(bf.id));
 			if (relevant.length > 0) {
-				for (const cs of relevant) if (cs.summary) lines.push(`- ${cs.summary.split("\n")[0]}`);
+				for (const bf of relevant) if (bf.summary) lines.push(`- ${bf.summary.split("\n")[0]}`);
 			} else if (release.isDependencyBump) lines.push("- Updated dependencies");
 			else if (release.isCascadeBump) lines.push("- Version bump via cascade rule");
 			lines.push("");
@@ -148,7 +148,7 @@ async function publishCommand(rootDir, opts) {
 	}
 	let toPublish = await findUnpublishedPackages(packages, config);
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-BkwIEaQg.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-B-Qg3DZH.mjs").then((n) => n.t);
 		const patterns = opts.filter.split(",").map((p) => p.trim());
 		toPublish = toPublish.filter((r) => patterns.some((p) => matchGlob(r.name, p)));
 	}
@@ -157,8 +157,9 @@ async function publishCommand(rootDir, opts) {
 		return;
 	}
 	const releasePlan = {
-		changesets: [],
-		releases: toPublish
+		bumpFiles: [],
+		releases: toPublish,
+		warnings: []
 	};
 	if (opts.dryRun) log.bold("Dry run — would publish:");
 	else log.bold("Publishing:");
@@ -168,7 +169,7 @@ async function publishCommand(rootDir, opts) {
 		dryRun: opts.dryRun,
 		tag: opts.tag
 	}, catalogs, detectedPm);
-	if (result.published.length > 0) log.success(`Published ${result.published.length} package(s)`);
+	if (result.published.length > 0) log.success(`🐸 Published ${result.published.length} package(s)`);
 	if (result.skipped.length > 0) log.dim(`Skipped ${result.skipped.length}: ${result.skipped.map((s) => s.name).join(", ")}`);
 	if (result.failed.length > 0) {
 		log.error(`Failed ${result.failed.length}: ${result.failed.map((f) => `${f.name} (${f.error})`).join(", ")}`);
@@ -186,11 +187,11 @@ async function publishCommand(rootDir, opts) {
 		const aggConfig = config.aggregateRelease;
 		const isAggregate = aggConfig === true || typeof aggConfig === "object" && aggConfig.enabled;
 		const aggTitle = typeof aggConfig === "object" ? aggConfig.title : void 0;
-		if (isAggregate) await createAggregateRelease(publishedReleases, releasePlan.changesets, rootDir, {
+		if (isAggregate) await createAggregateRelease(publishedReleases, releasePlan.bumpFiles, rootDir, {
 			dryRun: opts.dryRun,
 			title: aggTitle
 		});
-		else await createIndividualReleases(publishedReleases, releasePlan.changesets, rootDir, { dryRun: opts.dryRun });
+		else await createIndividualReleases(publishedReleases, releasePlan.bumpFiles, rootDir, { dryRun: opts.dryRun });
 	}
 }
 /**
@@ -211,7 +212,7 @@ async function findUnpublishedPackages(packages, _config) {
 			type: "patch",
 			oldVersion: pkg.version,
 			newVersion: pkg.version,
-			changesets: [],
+			bumpFiles: [],
 			isDependencyBump: false,
 			isCascadeBump: false
 		});
@@ -219,7 +220,7 @@ async function findUnpublishedPackages(packages, _config) {
 	return unpublished;
 }
 async function checkIfPublished(name, version, pkgConfig) {
-	const { runAsync, runArgsAsync, tryRunArgs } = await import("./shell-Dj7JRD_q.mjs").then((n) => n.i);
+	const { runAsync, runArgsAsync, tryRunArgs } = await import("./shell-CY7OD48z.mjs").then((n) => n.a);
 	if (pkgConfig?.checkPublished) try {
 		return (await runAsync(pkgConfig.checkPublished)).trim() === version;
 	} catch {

package/dist/{publish-pipeline-ChnqW8nR.mjs → publish-pipeline-CXuqce1N.mjs}

@@ -1,9 +1,9 @@
 import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
-import { a as readJson, c as writeJson } from "./fs-0AtnPUUe.mjs";
-import { r as resolveCatalogDep } from "./package-manager-DcI5TdDE.mjs";
-import { a as sq, n as runArgsAsync, o as tryRunArgs, r as runAsync } from "./shell-Dj7JRD_q.mjs";
-import { r as stripProtocol } from "./semver-BTzYh8vc.mjs";
-import { o as tagExists, t as createTag } from "./git-CGHVXXKw.mjs";
+import { a as readJson, l as updateJsonNestedField } from "./fs-DYR2XuFE.mjs";
+import { r as resolveCatalogDep } from "./package-manager-Clsmr-9r.mjs";
+import { i as runAsync, o as sq, r as runArgsAsync, s as tryRunArgs } from "./shell-CY7OD48z.mjs";
+import { r as stripProtocol } from "./semver-BJzWIuRz.mjs";
+import { c as tagExists, t as createTag } from "./git-YDedMddc.mjs";
 import { resolve } from "node:path";
 import { unlink } from "node:fs/promises";
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -160,7 +160,7 @@ async function packThenPublish(pkg, pkgConfig, config, packManager, opts) {
 		log.dim(`  Would publish with: ${publishArgs.join(" ")}`);
 		return;
 	}
-	const tarball = parseTarballPath(await runArgsAsync(packArgs, { cwd: pkg.dir }), pkg.dir);
+	const tarball = parseTarballPath(await runArgsAsync(packArgs, { cwd: pkg.dir }), pkg.dir, packManager);
 	try {
 		const publishArgs = buildPublishArgs(pkg, pkgConfig, config, opts, tarball);
 		log.dim(`  Publishing: ${publishArgs.join(" ")}`);
@@ -179,14 +179,22 @@ async function npmPublishDirect(pkg, pkgConfig, config, opts) {
 }
 function getPackArgs(pm) {
 	switch (pm) {
-		case "pnpm": return ["pnpm", "pack"];
+		case "pnpm": return [
+			"pnpm",
+			"pack",
+			"--json"
+		];
 		case "bun": return [
 			"bun",
 			"pm",
 			"pack"
 		];
 		case "yarn": return ["yarn", "pack"];
-		default: return ["npm", "pack"];
+		default: return [
+			"npm",
+			"pack",
+			"--json"
+		];
 	}
 }
 function buildPublishArgs(pkg, pkgConfig, config, opts, tarball) {
@@ -204,12 +212,14 @@ function buildPublishArgs(pkg, pkgConfig, config, opts, tarball) {
 }
 /**
 * Parse the tarball path from pack command output.
-* Each PM has different output formats:
-*   npm/pnpm: tarball filename on the last line
-*   bun:      tarball filename mid-output, summary lines after
-*   yarn:     'success Wrote tarball to "/path/to/foo.tgz".'
+* npm/pnpm use --json for structured output; bun/yarn fall back to regex parsing.
 */
-function parseTarballPath(output, cwd) {
+function parseTarballPath(output, cwd, pm) {
+	if (pm === "npm" || pm === "pnpm") try {
+		const parsed = JSON.parse(output);
+		const entry = Array.isArray(parsed) ? parsed[0] : parsed;
+		if (entry?.filename) return resolve(cwd, entry.filename);
+	} catch {}
 	const tgzMatch = output.match(/(?:^|["'\s])([^\s"']*\.tgz)/m);
 	if (tgzMatch) {
 		const tarball = tgzMatch[1];
@@ -239,7 +249,6 @@ function createGitTag(release, rootDir, opts) {
 async function resolveProtocolsInPlace(pkg, packages, releasePlan, catalogs) {
 	const pkgJsonPath = resolve(pkg.dir, "package.json");
 	const pkgJson = await readJson(pkgJsonPath);
-	let modified = false;
 	const releaseMap = new Map(releasePlan.releases.map((r) => [r.name, r]));
 	for (const depField of [
 		"dependencies",
@@ -265,13 +274,9 @@ async function resolveProtocolsInPlace(pkg, packages, releasePlan, catalogs) {
 					resolved = `${cleanRange === "*" ? "^" : cleanRange}${version}`;
 				} else resolved = cleanRange;
 			}
-			if (resolved) {
-				deps[depName] = resolved;
-				modified = true;
-			}
+			if (resolved) await updateJsonNestedField(pkgJsonPath, depField, depName, resolved);
 		}
 	}
-	if (modified) await writeJson(pkgJsonPath, pkgJson);
 }
 //#endregion
 export { publishPackages as t };

package/dist/release-plan-JNir7bSM.mjs

@@ -0,0 +1,264 @@
+import { h as maxBump, l as DEFAULT_BUMP_RULES, m as hasCascade, p as bumpLevel, s as matchGlob } from "./config-B-Qg3DZH.mjs";
+import { n as satisfies, t as bumpVersion } from "./semver-BJzWIuRz.mjs";
+//#region src/core/release-plan.ts
+/**
+* Build a release plan from pending bump files, the dependency graph, and config.
+* This is the core algorithm of bumpy.
+*
+* The propagation loop runs three phases until stable:
+*   Phase A — fix out-of-range dependencies (always runs)
+*   Phase B — enforce fixed/linked group constraints
+*   Phase C — apply cascades and proactive propagation rules
+*/
+function assembleReleasePlan(bumpFiles, packages, depGraph, config) {
+	if (bumpFiles.length === 0) return {
+		bumpFiles: [],
+		releases: [],
+		warnings: []
+	};
+	const planned = /* @__PURE__ */ new Map();
+	const warnings = [];
+	const cascadeOverrides = /* @__PURE__ */ new Map();
+	const suppressedPackages = /* @__PURE__ */ new Set();
+	for (const bf of bumpFiles) for (const release of bf.releases) {
+		if (!packages.has(release.name)) continue;
+		const bump = release.type;
+		if (bump === "none") {
+			suppressedPackages.add(release.name);
+			continue;
+		}
+		const existing = planned.get(release.name);
+		if (existing) {
+			existing.type = maxBump(existing.type, bump);
+			existing.bumpFiles.add(bf.id);
+		} else planned.set(release.name, {
+			type: bump,
+			suppressed: false,
+			isDependencyBump: false,
+			isCascadeBump: false,
+			bumpFiles: new Set([bf.id])
+		});
+		if (hasCascade(release)) {
+			if (!cascadeOverrides.has(release.name)) cascadeOverrides.set(release.name, /* @__PURE__ */ new Map());
+			const overrides = cascadeOverrides.get(release.name);
+			for (const [pattern, bumpType] of Object.entries(release.cascade)) {
+				const existing = overrides.get(pattern);
+				overrides.set(pattern, maxBump(existing, bumpType));
+			}
+		}
+	}
+	for (const name of suppressedPackages) if (!planned.has(name)) planned.set(name, {
+		type: "patch",
+		suppressed: true,
+		isDependencyBump: false,
+		isCascadeBump: false,
+		bumpFiles: /* @__PURE__ */ new Set()
+	});
+	let changed = true;
+	let iterations = 0;
+	const MAX_ITERATIONS = 100;
+	while (changed && iterations < MAX_ITERATIONS) {
+		changed = false;
+		iterations++;
+		for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			const pkg = packages.get(pkgName);
+			const newVersion = bumpVersion(pkg.version, bump.type);
+			const dependents = depGraph.getDependents(pkgName);
+			for (const dep of dependents) {
+				if (dep.depType === "devDependencies") continue;
+				const currentVersion = pkg.version;
+				if (satisfies(newVersion, dep.versionRange, currentVersion)) continue;
+				let depBump;
+				if (dep.depType === "peerDependencies") depBump = bump.type;
+				else depBump = "patch";
+				if (planned.get(dep.name)?.suppressed) throw new Error(`Cannot suppress bump for '${dep.name}' (via 'none' in bump file) — '${pkgName}' is bumping to ${newVersion} which breaks the declared range '${dep.versionRange}'. Either widen the range or remove the 'none' entry.`);
+				if (dep.depType === "peerDependencies" && depBump !== "patch") {
+					let resolvedRange = dep.versionRange.replace(/^workspace:/, "");
+					if (resolvedRange === "^" || resolvedRange === "~") resolvedRange = `${resolvedRange}${pkg.version}`;
+					if (/^\^0(\.|$)/.test(resolvedRange)) warnings.push(`${dep.name} gets a ${depBump} bump because ${pkgName}@${newVersion} is out of range for its peer dep "${dep.versionRange}" (resolves to ${resolvedRange}). npm treats ^ on 0.x as minor-breaking. Consider using >=0.x ranges for pre-1.0 peer deps.`);
+				}
+				if (applyBump(planned, dep.name, depBump, true, false, bump.bumpFiles)) changed = true;
+			}
+		}
+		for (const group of config.fixed) {
+			let groupBump;
+			for (const nameOrGlob of group) for (const [name, bump] of planned) {
+				if (bump.suppressed) continue;
+				if (matchGlob(name, nameOrGlob)) groupBump = maxBump(groupBump, bump.type);
+			}
+			if (!groupBump) continue;
+			for (const nameOrGlob of group) for (const [name] of packages) {
+				if (!matchGlob(name, nameOrGlob)) continue;
+				const existing = planned.get(name);
+				if (existing && existing.suppressed) continue;
+				if (existing) {
+					const newType = maxBump(existing.type, groupBump);
+					if (newType !== existing.type) {
+						existing.type = newType;
+						changed = true;
+					}
+				} else {
+					planned.set(name, {
+						type: groupBump,
+						suppressed: false,
+						isDependencyBump: false,
+						isCascadeBump: false,
+						bumpFiles: /* @__PURE__ */ new Set()
+					});
+					changed = true;
+				}
+			}
+		}
+		for (const group of config.linked) {
+			let groupBump;
+			for (const nameOrGlob of group) for (const [name, bump] of planned) {
+				if (bump.suppressed) continue;
+				if (matchGlob(name, nameOrGlob)) groupBump = maxBump(groupBump, bump.type);
+			}
+			if (!groupBump) continue;
+			for (const nameOrGlob of group) for (const [name] of packages) {
+				if (!matchGlob(name, nameOrGlob)) continue;
+				const existing = planned.get(name);
+				if (!existing || existing.suppressed) continue;
+				const newType = maxBump(existing.type, groupBump);
+				if (newType !== existing.type) {
+					existing.type = newType;
+					changed = true;
+				}
+			}
+		}
+		if (config.updateInternalDependencies !== "out-of-range") for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			if (config.updateInternalDependencies === "minor" && bumpLevel(bump.type) < bumpLevel("minor")) continue;
+			const bfOverrides = cascadeOverrides.get(pkgName);
+			if (bfOverrides) for (const [pattern, cascadeBumpType] of bfOverrides) for (const [targetName] of packages) {
+				if (!matchGlob(targetName, pattern)) continue;
+				if (planned.get(targetName)?.suppressed) continue;
+				if (applyBump(planned, targetName, cascadeBumpType, false, true, bump.bumpFiles)) changed = true;
+			}
+			const cascadeTo = packages.get(pkgName)?.bumpy?.cascadeTo;
+			if (cascadeTo) for (const [pattern, rule] of Object.entries(cascadeTo)) {
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				const cascadeBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				for (const [targetName] of packages) {
+					if (!matchGlob(targetName, pattern)) continue;
+					if (planned.get(targetName)?.suppressed) continue;
+					if (applyBump(planned, targetName, cascadeBump, false, true, bump.bumpFiles)) changed = true;
+				}
+			}
+			const dependents = depGraph.getDependents(pkgName);
+			for (const dep of dependents) {
+				const rule = resolveRule(dep.name, dep.depType, packages, config);
+				if (!rule) continue;
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				if (planned.get(dep.name)?.suppressed) continue;
+				const depBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				if (applyBump(planned, dep.name, depBump, true, false, bump.bumpFiles)) changed = true;
+			}
+		}
+		else for (const [pkgName, bump] of planned) {
+			if (bump.suppressed) continue;
+			const bfOverrides = cascadeOverrides.get(pkgName);
+			if (bfOverrides) for (const [pattern, cascadeBumpType] of bfOverrides) for (const [targetName] of packages) {
+				if (!matchGlob(targetName, pattern)) continue;
+				if (planned.get(targetName)?.suppressed) continue;
+				if (applyBump(planned, targetName, cascadeBumpType, false, true, bump.bumpFiles)) changed = true;
+			}
+			const cascadeTo = packages.get(pkgName)?.bumpy?.cascadeTo;
+			if (cascadeTo) for (const [pattern, rule] of Object.entries(cascadeTo)) {
+				if (!shouldTrigger(bump.type, rule.trigger)) continue;
+				const cascadeBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				for (const [targetName] of packages) {
+					if (!matchGlob(targetName, pattern)) continue;
+					if (planned.get(targetName)?.suppressed) continue;
+					if (applyBump(planned, targetName, cascadeBump, false, true, bump.bumpFiles)) changed = true;
+				}
+			}
+		}
+	}
+	for (const [name, bump] of planned) {
+		if (!bump.suppressed) continue;
+		const pkg = packages.get(name);
+		for (const [depName, depBump] of planned) {
+			if (depBump.suppressed) continue;
+			const depPkg = packages.get(depName);
+			const newDepVersion = bumpVersion(depPkg.version, depBump.type);
+			for (const depType of [
+				"dependencies",
+				"peerDependencies",
+				"optionalDependencies"
+			]) {
+				const range = pkg[depType]?.[depName];
+				if (!range) continue;
+				if (!satisfies(newDepVersion, range, depPkg.version)) throw new Error(`Cannot suppress bump for '${name}' (via 'none' in bump file) — '${depName}' is bumping to ${newDepVersion} which breaks the declared range '${range}'. Either widen the range or remove the 'none' entry.`);
+			}
+		}
+	}
+	const releases = [];
+	for (const [name, bump] of planned) {
+		if (bump.suppressed) continue;
+		const pkg = packages.get(name);
+		if (!pkg) continue;
+		const newVersion = bumpVersion(pkg.version, bump.type);
+		releases.push({
+			name,
+			type: bump.type,
+			oldVersion: pkg.version,
+			newVersion,
+			bumpFiles: [...bump.bumpFiles],
+			isDependencyBump: bump.isDependencyBump,
+			isCascadeBump: bump.isCascadeBump
+		});
+	}
+	releases.sort((a, b) => a.name.localeCompare(b.name));
+	for (const [name, pkg] of packages) for (const [depName, range] of Object.entries(pkg.peerDependencies)) if (range === "workspace:*" && packages.has(depName)) warnings.push(`${name} has peer dep "${depName}": "workspace:*" — this will be published as a fixed range which may not match your intent. Consider using "workspace:^" instead.`);
+	return {
+		bumpFiles,
+		releases,
+		warnings
+	};
+}
+/** Apply a bump to a package, upgrading if already planned. Returns true if anything changed. */
+function applyBump(planned, name, type, isDependencyBump, isCascadeBump, sourceBumpFiles) {
+	const existing = planned.get(name);
+	if (existing) {
+		if (existing.suppressed) return false;
+		const newType = maxBump(existing.type, type);
+		if (newType === existing.type) return false;
+		existing.type = newType;
+		if (isDependencyBump) existing.isDependencyBump = true;
+		if (isCascadeBump) existing.isCascadeBump = true;
+		for (const bf of sourceBumpFiles) existing.bumpFiles.add(bf);
+		return true;
+	}
+	planned.set(name, {
+		type,
+		suppressed: false,
+		isDependencyBump,
+		isCascadeBump,
+		bumpFiles: new Set(sourceBumpFiles)
+	});
+	return true;
+}
+/** Check if a bump level meets the trigger threshold */
+function shouldTrigger(bumpType, trigger) {
+	return bumpLevel(bumpType) >= bumpLevel(trigger);
+}
+/**
+* Resolve the dependency bump rule for a specific dependent + dep type.
+* Priority: per-package depType rules > global depType rules > defaults
+* Returns false if the rule is disabled.
+*/
+function resolveRule(dependentName, depType, packages, config) {
+	const dependent = packages.get(dependentName);
+	if (dependent?.bumpy?.dependencyBumpRules && depType in dependent.bumpy.dependencyBumpRules) return dependent.bumpy.dependencyBumpRules[depType];
+	if (depType in config.dependencyBumpRules) return config.dependencyBumpRules[depType];
+	const defaultRule = DEFAULT_BUMP_RULES[depType];
+	return defaultRule !== void 0 ? defaultRule : {
+		trigger: "patch",
+		bumpAs: "patch"
+	};
+}
+//#endregion
+export { assembleReleasePlan as t };

package/dist/{semver-BTzYh8vc.mjs → semver-BJzWIuRz.mjs}

@@ -1341,11 +1341,21 @@ function bumpVersion(version, type) {
 	if (!result) throw new Error(`Failed to bump ${version} by ${type}`);
 	return result;
 }
-/** Check if a version satisfies a range */
-function satisfies(version, range) {
+/**
+* Check if a version satisfies a range.
+* @param version - The version to check
+* @param range - The version range (may include workspace: or catalog: protocol)
+* @param currentVersion - The dependency's current version, used to resolve workspace:^ and workspace:~
+*/
+function satisfies(version, range, currentVersion) {
 	if (range.startsWith("workspace:")) {
 		const cleanRange = range.slice(10);
-		if (!cleanRange || cleanRange === "*" || cleanRange === "^" || cleanRange === "~") return true;
+		if (!cleanRange || cleanRange === "*") return true;
+		if (cleanRange === "^" || cleanRange === "~") {
+			if (!currentVersion) return true;
+			const resolved = `${cleanRange}${currentVersion}`;
+			return import_semver.default.satisfies(version, resolved);
+		}
 		return import_semver.default.satisfies(version, cleanRange);
 	}
 	if (range.startsWith("catalog:")) return true;

package/dist/{shell-Dj7JRD_q.mjs → shell-CY7OD48z.mjs}

@@ -1,7 +1,8 @@
 import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
-import { exec, execFile, execFileSync } from "node:child_process";
+import { exec, execFile, execFileSync, execSync } from "node:child_process";
 //#region src/utils/shell.ts
 var shell_exports = /* @__PURE__ */ __exportAll({
+	run: () => run,
 	runArgs: () => runArgs,
 	runArgsAsync: () => runArgsAsync,
 	runAsync: () => runAsync,
@@ -19,6 +20,23 @@ function sq(value) {
 function checkIntercept(args, opts) {
 	return null;
 }
+function run(cmd, opts) {
+	const result = checkIntercept(cmd.split(/\s+/), opts);
+	if (result?.intercepted) {
+		if ("error" in result) throw new Error(result.error);
+		return result.result;
+	}
+	return execSync(cmd, {
+		cwd: opts?.cwd,
+		input: opts?.input,
+		encoding: "utf-8",
+		stdio: [
+			opts?.input ? "pipe" : "pipe",
+			"pipe",
+			"pipe"
+		]
+	}).trim();
+}
 function runAsync(cmd, opts) {
 	const result = checkIntercept(cmd.split(/\s+/), opts);
 	if (result?.intercepted) {
@@ -89,4 +107,4 @@ function tryRunArgs(args, opts) {
 	}
 }
 //#endregion
-export { sq as a, shell_exports as i, runArgsAsync as n, tryRunArgs as o, runAsync as r, runArgs as t };
+export { shell_exports as a, runAsync as i, runArgs as n, sq as o, runArgsAsync as r, tryRunArgs as s, run as t };

package/dist/{status--Q8yAxQ4.mjs → status-EGYqULJg.mjs}

@@ -1,41 +1,41 @@
 import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
-import { a as loadConfig } from "./config-BkwIEaQg.mjs";
-import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
-import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
-import { r as readChangesets } from "./changeset-UCZdSRDv.mjs";
-import { t as assembleReleasePlan } from "./release-plan-BEzwApuK.mjs";
+import { a as loadConfig } from "./config-B-Qg3DZH.mjs";
+import { t as discoverPackages } from "./workspace-DWXlwcH4.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { r as readBumpFiles } from "./bump-file-DVqR3k67.mjs";
+import { t as assembleReleasePlan } from "./release-plan-JNir7bSM.mjs";
 //#region src/commands/status.ts
 async function statusCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
 	const packages = await discoverPackages(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
-	const changesets = await readChangesets(rootDir);
-	if (changesets.length === 0) {
+	const bumpFiles = await readBumpFiles(rootDir);
+	if (bumpFiles.length === 0) {
 		if (opts.json) console.log(JSON.stringify({
-			changesets: [],
+			bumpFiles: [],
 			releases: [],
 			packageNames: []
 		}, null, 2));
-		else if (!opts.packagesOnly) log.info("No pending changesets.");
+		else if (!opts.packagesOnly) log.info("No pending bump files.");
 		process.exit(1);
 	}
-	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	const plan = assembleReleasePlan(bumpFiles, packages, depGraph, config);
 	let releases = plan.releases;
 	if (opts.bumpType) {
 		const types = opts.bumpType.split(",").map((t) => t.trim());
 		releases = releases.filter((r) => types.includes(r.type));
 	}
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-BkwIEaQg.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-B-Qg3DZH.mjs").then((n) => n.t);
 		const patterns = opts.filter.split(",").map((p) => p.trim());
 		releases = releases.filter((r) => patterns.some((p) => matchGlob(r.name, p)));
 	}
 	if (opts.json) {
 		const jsonOutput = {
-			changesets: plan.changesets.map((cs) => ({
-				id: cs.id,
-				summary: cs.summary,
-				releases: cs.releases.map((r) => ({
+			bumpFiles: plan.bumpFiles.map((bf) => ({
+				id: bf.id,
+				summary: bf.summary,
+				releases: bf.releases.map((r) => ({
 					name: r.name,
 					type: r.type
 				}))
@@ -46,7 +46,7 @@ async function statusCommand(rootDir, opts) {
 				oldVersion: r.oldVersion,
 				newVersion: r.newVersion,
 				dir: packages.get(r.name)?.relativeDir,
-				changesets: r.changesets,
+				bumpFiles: r.bumpFiles,
 				isDependencyBump: r.isDependencyBump,
 				isCascadeBump: r.isCascadeBump
 			})),
@@ -59,7 +59,7 @@ async function statusCommand(rootDir, opts) {
 		for (const r of releases) console.log(r.name);
 		return;
 	}
-	log.bold(`${changesets.length} changeset(s) pending\n`);
+	log.bold(`${bumpFiles.length} bump file(s) pending\n`);
 	if (releases.length === 0) {
 		log.warn("No packages match the current filters.");
 		return;
@@ -87,12 +87,16 @@ async function statusCommand(rootDir, opts) {
 		for (const r of group) printRelease(r, packages);
 		console.log();
 	}
+	if (plan.warnings.length > 0) {
+		for (const w of plan.warnings) log.warn(w);
+		console.log();
+	}
 	if (opts.verbose) {
-		log.bold("Changesets:");
-		for (const cs of plan.changesets) {
-			console.log(`  ${colorize(cs.id, "cyan")}`);
-			for (const r of cs.releases) console.log(`    ${r.name}: ${r.type}`);
-			if (cs.summary) console.log(`    ${colorize(cs.summary.split("\n")[0], "dim")}`);
+		log.bold("Bump files:");
+		for (const bf of plan.bumpFiles) {
+			console.log(`  ${colorize(bf.id, "cyan")}`);
+			for (const r of bf.releases) console.log(`    ${r.name}: ${r.type}`);
+			if (bf.summary) console.log(`    ${colorize(bf.summary.split("\n")[0], "dim")}`);
 		}
 	}
 }