@varlock/bumpy 1.6.0 → 1.7.1

package/dist/{semver-DfQyVLM_.mjs → release-plan-iZvGo-SB.mjs}

@@ -1,4 +1,69 @@
-import { i as __commonJSMin, o as __toESM } from "./logger-C2dEe5Su.mjs";
+import { i as __commonJSMin, s as __toESM } from "./logger-BgksGFuf.mjs";
+import { c as maxBump, n as DEFAULT_BUMP_RULES, o as bumpLevel, s as hasCascade } from "./types-BX4pfmKh.mjs";
+import { s as matchGlob } from "./config-BcmlSJJd.mjs";
+//#region src/core/dep-graph.ts
+var DependencyGraph = class {
+	/** Map from package name → packages that depend on it */
+	dependents = /* @__PURE__ */ new Map();
+	/** Set of all internal package names */
+	internalPackages;
+	constructor(packages) {
+		this.internalPackages = new Set(packages.keys());
+		this.build(packages);
+	}
+	build(packages) {
+		for (const [name, pkg] of packages) {
+			const depTypes = [
+				["dependencies", pkg.dependencies],
+				["devDependencies", pkg.devDependencies],
+				["peerDependencies", pkg.peerDependencies],
+				["optionalDependencies", pkg.optionalDependencies]
+			];
+			for (const [depType, deps] of depTypes) for (const [depName, versionRange] of Object.entries(deps)) {
+				if (!this.internalPackages.has(depName)) continue;
+				if (!this.dependents.has(depName)) this.dependents.set(depName, []);
+				this.dependents.get(depName).push({
+					name,
+					depType,
+					versionRange
+				});
+			}
+		}
+	}
+	/** Get all packages that depend on the given package */
+	getDependents(pkgName) {
+		return this.dependents.get(pkgName) || [];
+	}
+	/** Check if a package is an internal workspace package */
+	isInternal(pkgName) {
+		return this.internalPackages.has(pkgName);
+	}
+	/** Get all internal package names */
+	allPackages() {
+		return [...this.internalPackages];
+	}
+	/** Topological sort — returns packages in dependency order (deps first) */
+	topologicalSort(packages) {
+		const visited = /* @__PURE__ */ new Set();
+		const result = [];
+		const visit = (name) => {
+			if (visited.has(name)) return;
+			visited.add(name);
+			const pkg = packages.get(name);
+			if (!pkg) return;
+			for (const deps of [
+				pkg.dependencies,
+				pkg.devDependencies,
+				pkg.peerDependencies,
+				pkg.optionalDependencies
+			]) for (const depName of Object.keys(deps)) if (this.internalPackages.has(depName)) visit(depName);
+			result.push(name);
+		};
+		for (const name of this.internalPackages) visit(name);
+		return result;
+	}
+};
+//#endregion
 //#region ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const SEMVER_SPEC_VERSION = "2.0.0";
@@ -1367,4 +1432,249 @@ function stripProtocol(range) {
 	return range.replace(/^workspace:/, "");
 }
 //#endregion
-export { satisfies as n, stripProtocol as r, bumpVersion as t };
+//#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();
+	for (const bf of bumpFiles) for (const release of bf.releases) {
+		if (!packages.has(release.name)) continue;
+		const bump = release.type;
+		if (bump === "none") 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,
+			isDependencyBump: false,
+			isCascadeBump: false,
+			isGroupBump: false,
+			bumpFiles: new Set([bf.id]),
+			bumpSources: /* @__PURE__ */ new Map()
+		});
+		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));
+			}
+		}
+	}
+	let changed = true;
+	let iterations = 0;
+	const MAX_ITERATIONS = 100;
+	while (changed && iterations < MAX_ITERATIONS) {
+		changed = false;
+		iterations++;
+		for (const [pkgName, bump] of planned) {
+			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 (dep.depType === "peerDependencies" && depBump !== "patch" && bump.type !== "major") {
+					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, pkgName)) changed = true;
+			}
+		}
+		for (const group of config.fixed) {
+			let groupBump;
+			const groupSources = [];
+			for (const nameOrGlob of group) for (const [name, bump] of planned) if (matchGlob(name, nameOrGlob)) {
+				if (!groupBump || bumpLevel(bump.type) > bumpLevel(groupBump)) {
+					groupBump = bump.type;
+					groupSources.length = 0;
+					groupSources.push(name);
+				} else if (bump.type === groupBump) groupSources.push(name);
+			}
+			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) {
+					const newType = maxBump(existing.type, groupBump);
+					if (newType !== existing.type) {
+						existing.type = newType;
+						existing.isGroupBump = true;
+						for (const src of groupSources) if (src !== name) existing.bumpSources.set(src, groupBump);
+						changed = true;
+					}
+				} else {
+					planned.set(name, {
+						type: groupBump,
+						isDependencyBump: false,
+						isCascadeBump: false,
+						isGroupBump: true,
+						bumpFiles: /* @__PURE__ */ new Set(),
+						bumpSources: new Map(groupSources.filter((s) => s !== name).map((s) => [s, groupBump]))
+					});
+					changed = true;
+				}
+			}
+		}
+		for (const group of config.linked) {
+			let groupBump;
+			const groupSources = [];
+			for (const nameOrGlob of group) for (const [name, bump] of planned) if (matchGlob(name, nameOrGlob)) {
+				if (!groupBump || bumpLevel(bump.type) > bumpLevel(groupBump)) {
+					groupBump = bump.type;
+					groupSources.length = 0;
+					groupSources.push(name);
+				} else if (bump.type === groupBump) groupSources.push(name);
+			}
+			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) continue;
+				const newType = maxBump(existing.type, groupBump);
+				if (newType !== existing.type) {
+					existing.type = newType;
+					existing.isGroupBump = true;
+					for (const src of groupSources) if (src !== name) existing.bumpSources.set(src, groupBump);
+					changed = true;
+				}
+			}
+		}
+		if (config.updateInternalDependencies !== "out-of-range") for (const [pkgName, bump] of planned) {
+			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 (applyBump(planned, targetName, cascadeBumpType, false, true, pkgName)) 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 (applyBump(planned, targetName, cascadeBump, false, true, pkgName)) 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;
+				const depBump = rule.bumpAs === "match" ? bump.type : rule.bumpAs;
+				if (applyBump(planned, dep.name, depBump, true, false, pkgName)) changed = true;
+			}
+		}
+		else for (const [pkgName, bump] of planned) {
+			const bfOverrides = cascadeOverrides.get(pkgName);
+			if (bfOverrides) for (const [pattern, cascadeBumpType] of bfOverrides) for (const [targetName] of packages) {
+				if (!matchGlob(targetName, pattern)) continue;
+				if (applyBump(planned, targetName, cascadeBumpType, false, true, pkgName)) 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 (applyBump(planned, targetName, cascadeBump, false, true, pkgName)) changed = true;
+				}
+			}
+		}
+	}
+	const releases = [];
+	for (const [name, bump] of planned) {
+		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,
+			isGroupBump: bump.isGroupBump,
+			bumpSources: [...bump.bumpSources].map(([srcName, contributedType]) => {
+				const srcBump = planned.get(srcName);
+				const srcPkg = packages.get(srcName);
+				return {
+					name: srcName,
+					newVersion: srcPkg && srcBump ? bumpVersion(srcPkg.version, srcBump.type) : "unknown",
+					bumpType: contributedType
+				};
+			})
+		});
+	}
+	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, sourcePackageName) {
+	const existing = planned.get(name);
+	if (existing) {
+		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;
+		existing.bumpSources.set(sourcePackageName, type);
+		return true;
+	}
+	planned.set(name, {
+		type,
+		isDependencyBump,
+		isCascadeBump,
+		isGroupBump: false,
+		bumpFiles: /* @__PURE__ */ new Set(),
+		bumpSources: new Map([[sourcePackageName, type]])
+	});
+	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 { DependencyGraph as a, stripProtocol as i, bumpVersion as n, satisfies as r, assembleReleasePlan as t };

package/dist/{shell-u3bYGxNy.mjs → shell-C8KgKnMQ.mjs}

@@ -1,4 +1,4 @@
-import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
+import { a as __exportAll } from "./logger-BgksGFuf.mjs";
 import { exec, execFile, execFileSync, execSync } from "node:child_process";
 //#region src/utils/shell.ts
 var shell_exports = /* @__PURE__ */ __exportAll({

package/dist/{status-lS56U6F_.mjs → status-CpGvpJBm.mjs}

@@ -1,10 +1,8 @@
-import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
-import { a as loadConfig } from "./config-D13G4-R8.mjs";
-import { t as discoverPackages } from "./workspace-Yt7qwsML.mjs";
-import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
-import { r as readBumpFiles, t as filterBranchBumpFiles } from "./bump-file-CoaSxqne.mjs";
-import { t as assembleReleasePlan } from "./release-plan-C1Lz9rl_.mjs";
-import { i as getCurrentBranch, r as getChangedFiles } from "./git-ukq7VTuZ.mjs";
+import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
+import { a as loadConfig } from "./config-BcmlSJJd.mjs";
+import { a as discoverPackages, r as readBumpFiles, t as filterBranchBumpFiles } from "./bump-file-4cnuDyfW.mjs";
+import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-iZvGo-SB.mjs";
+import { i as getCurrentBranch, r as getChangedFiles } from "./git-nTR-JccX.mjs";
 //#region src/commands/status.ts
 async function statusCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
@@ -31,7 +29,7 @@ async function statusCommand(rootDir, opts) {
 		releases = releases.filter((r) => types.includes(r.type));
 	}
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-D13G4-R8.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-BcmlSJJd.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)));
 	}
@@ -123,8 +121,8 @@ function getPublishTargets(pkg, pkgConfig, _config) {
 	if (!pkg) return [];
 	if (pkg.private && !pkgConfig.publishCommand) return [];
 	const targets = [];
-	if (pkgConfig.publishCommand) targets.push("custom");
-	if (!pkgConfig.publishCommand && !pkgConfig.skipNpmPublish) targets.push("npm");
+	if (pkgConfig.publishCommand) targets.push({ type: "custom" });
+	if (!pkgConfig.publishCommand && !pkgConfig.skipNpmPublish) targets.push({ type: "npm" });
 	return targets;
 }
 //#endregion

package/dist/{version-BjjnO2ii.mjs → version-nJ0vhPWw.mjs}

@@ -1,13 +1,11 @@
-import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
-import { a as loadConfig } from "./config-D13G4-R8.mjs";
-import { n as detectWorkspaces } from "./package-manager-CClZtIHP.mjs";
-import { t as discoverPackages } from "./workspace-Yt7qwsML.mjs";
-import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
-import { n as runArgs, s as tryRunArgs } from "./shell-u3bYGxNy.mjs";
-import { r as readBumpFiles } from "./bump-file-CoaSxqne.mjs";
-import { t as assembleReleasePlan } from "./release-plan-C1Lz9rl_.mjs";
-import { t as applyReleasePlan } from "./apply-release-plan-DNpoi7cS.mjs";
-import { t as resolveCommitMessage } from "./commit-message-3e4KhzFV.mjs";
+import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
+import { a as loadConfig } from "./config-BcmlSJJd.mjs";
+import { n as detectWorkspaces } from "./package-manager-BQPwXwu5.mjs";
+import { a as discoverPackages, r as readBumpFiles } from "./bump-file-4cnuDyfW.mjs";
+import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-iZvGo-SB.mjs";
+import { n as runArgs, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-CAx8E9MJ.mjs";
+import { t as resolveCommitMessage } from "./commit-message-CSWVKPJ-.mjs";
 //#region src/commands/version.ts
 async function versionCommand(rootDir, opts = {}) {
 	const config = await loadConfig(rootDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlock/bumpy",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Modern monorepo versioning and changelog tool",
   "keywords": [
     "bump",

package/dist/dep-graph-E-9-eQ2J.mjs

@@ -1,64 +0,0 @@
-//#region src/core/dep-graph.ts
-var DependencyGraph = class {
-	/** Map from package name → packages that depend on it */
-	dependents = /* @__PURE__ */ new Map();
-	/** Set of all internal package names */
-	internalPackages;
-	constructor(packages) {
-		this.internalPackages = new Set(packages.keys());
-		this.build(packages);
-	}
-	build(packages) {
-		for (const [name, pkg] of packages) {
-			const depTypes = [
-				["dependencies", pkg.dependencies],
-				["devDependencies", pkg.devDependencies],
-				["peerDependencies", pkg.peerDependencies],
-				["optionalDependencies", pkg.optionalDependencies]
-			];
-			for (const [depType, deps] of depTypes) for (const [depName, versionRange] of Object.entries(deps)) {
-				if (!this.internalPackages.has(depName)) continue;
-				if (!this.dependents.has(depName)) this.dependents.set(depName, []);
-				this.dependents.get(depName).push({
-					name,
-					depType,
-					versionRange
-				});
-			}
-		}
-	}
-	/** Get all packages that depend on the given package */
-	getDependents(pkgName) {
-		return this.dependents.get(pkgName) || [];
-	}
-	/** Check if a package is an internal workspace package */
-	isInternal(pkgName) {
-		return this.internalPackages.has(pkgName);
-	}
-	/** Get all internal package names */
-	allPackages() {
-		return [...this.internalPackages];
-	}
-	/** Topological sort — returns packages in dependency order (deps first) */
-	topologicalSort(packages) {
-		const visited = /* @__PURE__ */ new Set();
-		const result = [];
-		const visit = (name) => {
-			if (visited.has(name)) return;
-			visited.add(name);
-			const pkg = packages.get(name);
-			if (!pkg) return;
-			for (const deps of [
-				pkg.dependencies,
-				pkg.devDependencies,
-				pkg.peerDependencies,
-				pkg.optionalDependencies
-			]) for (const depName of Object.keys(deps)) if (this.internalPackages.has(depName)) visit(depName);
-			result.push(name);
-		};
-		for (const name of this.internalPackages) visit(name);
-		return result;
-	}
-};
-//#endregion
-export { DependencyGraph as t };