@varlock/bumpy 1.13.1 → 1.14.0-rc.0

package/dist/{publish-h6rM58Cq.mjs → publish-Cz0e4KYT.mjs}

@@ -1,14 +1,17 @@
-import { n as log, o as __require, t as colorize } from "./logger-BgksGFuf.mjs";
-import { a as loadConfig } from "./config-D_4GYDJi.mjs";
+import { n as log, o as __require, s as __toESM, t as colorize } from "./logger-BgksGFuf.mjs";
+import { a as loadConfig } from "./config-0we4ISZX.mjs";
 import { r as detectWorkspaces } from "./package-manager-Db_vTztt.mjs";
-import { s as discoverWorkspace } from "./bump-file-B7hmXZlB.mjs";
-import { a as DependencyGraph } from "./release-plan-mK7iGeGq.mjs";
+import { c as discoverWorkspace, i as readBumpFiles } from "./bump-file-mRJeReRJ.mjs";
+import { a as require_semver, o as DependencyGraph, t as assembleReleasePlan } from "./release-plan-C84pcBi-.mjs";
 import { r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { i as loadFormatter, n as generateChangelogEntry } from "./changelog-CbaET5V6.mjs";
-import { c as hasUncommittedChanges, l as pushWithTags } from "./git-DJJ64SW9.mjs";
-import { t as publishPackages } from "./publish-pipeline-DSj14dW6.mjs";
-import { CI_PLAN_CACHE_PATH } from "./ci-CIamssoq.mjs";
+import { i as loadFormatter, n as generateChangelogEntry } from "./changelog-DuFhnJRO.mjs";
+import { f as tagExists, l as hasUncommittedChanges, n as forcePushTag } from "./git-DAWj8LyV.mjs";
+import { n as willUseOidcExclusively, t as publishPackages } from "./publish-pipeline-BD8mLbL9.mjs";
+import { channelNames, resolveActiveChannel } from "./channels-CFXZkyGd.mjs";
+import { r as writeChannelVersionsInPlace, t as buildChannelReleasePlan } from "./prerelease-Blnk8FE1.mjs";
+import { CI_PLAN_CACHE_PATH } from "./ci-hO7tAbCN.mjs";
 //#region src/core/github-release.ts
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
 /** Get the current HEAD commit SHA */
 function getHeadSha(rootDir) {
 	return tryRunArgs([
@@ -67,6 +70,7 @@ async function createIndividualReleases(releases, bumpFiles, rootDir, opts = {})
 				"--notes",
 				body
 			];
+			if (/-/.test(release.newVersion)) args.push("--prerelease");
 			if (headSha) args.push("--target", headSha);
 			await withReleaseToken(() => runArgsAsync(args, { cwd: rootDir }));
 			log.dim(`  Created GitHub release: ${title}`);
@@ -193,7 +197,7 @@ async function findReleaseByTag(tag, rootDir) {
 	}
 }
 /** Create a draft GitHub release */
-async function createDraftRelease(tag, title, body, rootDir, targetSha) {
+async function createDraftRelease(tag, title, body, rootDir, targetSha, opts) {
 	const args = [
 		"gh",
 		"release",
@@ -205,6 +209,7 @@ async function createDraftRelease(tag, title, body, rootDir, targetSha) {
 		body,
 		"--draft"
 	];
+	if (opts?.prerelease) args.push("--prerelease");
 	if (targetSha) args.push("--target", targetSha);
 	await withReleaseToken(() => runArgsAsync(args, { cwd: rootDir }));
 }
@@ -293,7 +298,13 @@ async function finalizeSupersededDrafts(packageName, newVersion, rootDir) {
 //#region src/commands/publish.ts
 /**
 * Publish packages that have been versioned but not yet published.
-* Detects unpublished versions by comparing package.json versions against npm registry.
+*
+* On the base branch: detects unpublished versions by comparing package.json versions
+* against the npm registry.
+*
+* On a channel branch: prerelease versions are never committed, so they are computed
+* here — targets from the cycle's bump files, counters from the registry — written
+* transiently into the working tree, published to the channel's dist-tag, and restored.
 */
 async function publishCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
@@ -304,7 +315,21 @@ async function publishCommand(rootDir, opts) {
 		log.warn("You have uncommitted changes. Commit or stash them before publishing.");
 		process.exit(1);
 	}
+	const channel = resolveActiveChannel(rootDir, config, opts.channel);
+	if (channel) {
+		await publishChannel(rootDir, config, packages, catalogs, detectedPm, depGraph, channel, opts);
+		return;
+	}
 	let toPublish = await findUnpublishedWithCache(rootDir, packages, config);
+	if (Object.keys(config.channels || {}).length > 0) {
+		const prereleases = toPublish.filter((r) => import_semver.default.prerelease(r.newVersion) !== null);
+		if (prereleases.length > 0) {
+			log.error("Refusing to publish prerelease versions outside a channel:");
+			for (const r of prereleases) log.error(`  • ${r.name}@${r.newVersion}`);
+			log.error("Prerelease versions should never be committed — see https://bumpy.varlock.dev/docs/prereleases");
+			process.exit(1);
+		}
+	}
 	if (opts.excludePackages && opts.excludePackages.size > 0) {
 		const excluded = toPublish.filter((r) => opts.excludePackages.has(r.name));
 		if (excluded.length > 0) {
@@ -313,7 +338,7 @@ async function publishCommand(rootDir, opts) {
 		}
 	}
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-D_4GYDJi.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-0we4ISZX.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)));
 	}
@@ -323,15 +348,92 @@ async function publishCommand(rootDir, opts) {
 	}
 	const recoveredBumpFiles = opts.recoveredBumpFiles || [];
 	if (recoveredBumpFiles.length > 0) for (const release of toPublish) release.bumpFiles = recoveredBumpFiles.filter((bf) => bf.releases.some((r) => r.name === release.name)).map((bf) => bf.id);
-	const releasePlan = {
+	await runPublishFlow(rootDir, config, packages, catalogs, detectedPm, depGraph, {
 		bumpFiles: recoveredBumpFiles,
 		releases: toPublish,
 		warnings: []
-	};
+	}, {
+		dryRun: opts.dryRun,
+		tag: opts.tag,
+		noPush: opts.noPush
+	});
+}
+/**
+* Publish a prerelease cycle from a channel branch.
+*
+* The cycle = every bump file on the branch (pending at root or in other channels'
+* dirs, plus shipped in this channel's dir). The whole cycle republishes together
+* each time so the channel dist-tag always points at one coherent, exact-pinned set.
+*/
+async function publishChannel(rootDir, config, packages, catalogs, detectedPm, depGraph, channel, opts) {
+	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
+	if (parseErrors.length > 0) {
+		for (const err of parseErrors) log.error(err);
+		process.exit(1);
+	}
+	if (bumpFiles.filter((bf) => bf.channel === channel.name).length === 0) {
+		log.info(`Nothing has shipped on channel "${channel.name}" yet (no bump files in .bumpy/${channel.name}/).\n  Run \`bumpy version\` on the channel branch (or merge the release PR) first.`);
+		return;
+	}
+	log.bold(`Channel "${channel.name}" — preid "-${channel.preid}.N", dist-tag @${channel.tag}\n`);
+	const { plan, alreadyPublished, warnings } = await buildChannelReleasePlan(assembleReleasePlan(bumpFiles, packages, depGraph, config, { prereleasePreid: channel.preid }), channel, packages, rootDir);
+	for (const w of warnings) log.warn(w);
+	for (const skip of alreadyPublished) log.dim(`  Skipping ${skip.name}@${skip.version} — already published from this commit`);
+	if (plan.releases.length === 0) {
+		log.info("All cycle packages already published from this commit.");
+		return;
+	}
+	let toPublish = plan.releases;
+	if (opts.filter) {
+		const { matchGlob } = await import("./config-0we4ISZX.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)));
+		if (toPublish.length === 0) {
+			log.info("No cycle packages match the filter.");
+			return;
+		}
+	}
+	let restore = null;
+	if (!opts.dryRun) restore = await writeChannelVersionsInPlace(plan, packages);
+	try {
+		await runPublishFlow(rootDir, config, packages, catalogs, detectedPm, depGraph, {
+			bumpFiles: plan.bumpFiles,
+			releases: toPublish,
+			warnings: []
+		}, {
+			dryRun: opts.dryRun,
+			tag: opts.tag ?? channel.tag,
+			noPush: opts.noPush
+		});
+	} finally {
+		if (restore) {
+			await restore();
+			log.dim("  Restored package.json files (prerelease versions are not committed)");
+		}
+	}
+}
+/**
+* The shared publish flow: OIDC checks, draft GitHub releases, topological publish,
+* release metadata updates, tag pushes. Used by both the stable and channel paths.
+* Mutates `releasePlan.releases` as packages are filtered out (already published, etc.).
+*/
+async function runPublishFlow(rootDir, config, packages, catalogs, detectedPm, depGraph, releasePlan, opts) {
+	let toPublish = releasePlan.releases;
 	if (opts.dryRun) log.bold("Dry run — would publish:");
 	else log.bold("Publishing:");
 	for (const r of toPublish) console.log(`  ${r.name}@${colorize(r.newVersion, "cyan")}`);
 	console.log();
+	if (willUseOidcExclusively(rootDir)) {
+		const newPackages = await findPackagesMissingFromNpm(toPublish, packages);
+		if (newPackages.length > 0) {
+			const logFn = opts.dryRun ? log.warn : log.error;
+			logFn(`Trusted publishing (OIDC) cannot create a new package. The following don't exist on npm yet:`);
+			for (const name of newPackages) logFn(`  • ${name}`);
+			logFn(`Publish a 0.0.0 placeholder version manually to claim the name, then configure`);
+			logFn(`trusted publishing on npmjs.com. Bumpy will then publish the real version via OIDC.`);
+			if (!opts.dryRun) process.exit(1);
+		}
+	}
 	const formatter = config.changelog !== false ? await loadFormatter(config.changelog, rootDir) : void 0;
 	const ghAvailable = isGhAvailable();
 	const publishTargetsByPkg = /* @__PURE__ */ new Map();
@@ -370,7 +472,7 @@ async function publishCommand(rootDir, opts) {
 				const title = `${release.name} v${release.newVersion}`;
 				const headSha = getHeadSha(rootDir);
 				try {
-					await createDraftRelease(tag, title, body, rootDir, headSha || void 0);
+					await createDraftRelease(tag, title, body, rootDir, headSha || void 0, { prerelease: import_semver.default.prerelease(release.newVersion) !== null });
 					log.dim(`  Created draft release: ${title}`);
 					releaseMetadataByPkg.set(release.name, {
 						tag,
@@ -489,12 +591,22 @@ async function publishCommand(rootDir, opts) {
 		log.error(`Failed ${result.failed.length}: ${result.failed.map((f) => `${f.name} (${f.error})`).join(", ")}`);
 		process.exit(1);
 	}
-	if (!opts.dryRun && !opts.noPush && result.published.length > 0) try {
+	if (!opts.dryRun && !opts.noPush && result.published.length > 0) {
+		const failed = new Set(result.failed.map((f) => f.name));
+		const pushed = [];
 		log.step("Pushing tags...");
-		pushWithTags({ cwd: rootDir });
-		log.success("Pushed tags to remote");
-	} catch (err) {
-		log.warn(`Failed to push tags: ${err instanceof Error ? err.message : err}`);
+		for (const release of releasePlan.releases) {
+			if (failed.has(release.name)) continue;
+			const tag = `${release.name}@${release.newVersion}`;
+			if (!tagExists(tag, { cwd: rootDir })) continue;
+			try {
+				forcePushTag(tag, { cwd: rootDir });
+				pushed.push(tag);
+			} catch (err) {
+				log.warn(`  Failed to push tag ${tag}: ${err instanceof Error ? err.message : err}`);
+			}
+		}
+		if (pushed.length > 0) log.success(`Pushed ${pushed.length} tag(s) to remote`);
 	}
 	if (!ghAvailable && result.published.length > 0) await createIndividualReleases(releasePlan.releases.filter((r) => result.published.some((p) => p.name === r.name)), releasePlan.bumpFiles, rootDir, {
 		dryRun: opts.dryRun,
@@ -618,5 +730,38 @@ async function checkIfPublished(name, version, pkgConfig) {
 		return false;
 	}
 }
+/**
+* Check whether a package exists on npm at all (any version).
+* Returns true if the package is registered, false if it doesn't exist or the query fails.
+*/
+async function packageExistsOnNpm(name, registry) {
+	const args = [
+		"npm",
+		"info",
+		name,
+		"name"
+	];
+	if (registry) args.push("--registry", registry);
+	try {
+		return (await runArgsAsync(args)).trim() === name;
+	} catch {
+		return false;
+	}
+}
+/**
+* Filter `toPublish` to package names that don't exist on npm yet.
+* Skips packages not going through the standard npm publish flow.
+*/
+async function findPackagesMissingFromNpm(toPublish, packages) {
+	const missing = [];
+	await Promise.all(toPublish.map(async (release) => {
+		const pkg = packages.get(release.name);
+		const pkgConfig = pkg.bumpy || {};
+		if (pkgConfig.publishCommand || pkgConfig.skipNpmPublish) return;
+		if (pkg.private && !pkgConfig.publishCommand) return;
+		if (!await packageExistsOnNpm(release.name, pkgConfig.registry)) missing.push(release.name);
+	}));
+	return missing;
+}
 //#endregion
 export { findUnpublishedPackages, publishCommand };

package/dist/{publish-pipeline-DSj14dW6.mjs → publish-pipeline-BD8mLbL9.mjs}

@@ -1,9 +1,9 @@
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
 import { a as readJson, u as updateJsonNestedField } from "./fs-CBXKZhoU.mjs";
 import { s as resolveCatalogDep } from "./package-manager-Db_vTztt.mjs";
-import { i as stripProtocol } from "./release-plan-mK7iGeGq.mjs";
+import { i as stripProtocol } from "./release-plan-C84pcBi-.mjs";
 import { i as runAsync, o as sq, r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { d as tagExists, t as createTag } from "./git-DJJ64SW9.mjs";
+import { f as tagExists, t as createTag } from "./git-DAWj8LyV.mjs";
 import { resolve } from "node:path";
 import { unlink } from "node:fs/promises";
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -23,6 +23,21 @@ function detectOidcProvider() {
 	if (process.env.CIRCLECI && process.env.NPM_ID_TOKEN) return "circleci";
 	return null;
 }
+/**
+* Returns true when OIDC trusted publishing is the only available npm auth path:
+* an OIDC provider is detected AND no token env vars or .npmrc auth are present.
+*
+* Used to gate checks that only matter when OIDC will definitely be used — e.g.
+* erroring when a brand-new package can't be bootstrapped via trusted publishing.
+* Detection alone is leaky (id-token: write is also set for provenance), so this
+* helper avoids false positives when a token fallback exists.
+*/
+function willUseOidcExclusively(rootDir) {
+	if (!detectOidcProvider()) return false;
+	if (process.env.NPM_TOKEN || process.env.NODE_AUTH_TOKEN) return false;
+	const npmrcPath = resolve(rootDir, ".npmrc");
+	return !(existsSync(npmrcPath) ? readFileSync(npmrcPath, "utf-8") : "").includes(":_authToken=");
+}
 const OIDC_NPM_UPGRADE_HINTS = {
 	"github-actions": "Add `actions/setup-node@v6` with `node-version: lts/*` to your workflow",
 	gitlab: "Use a Node.js image with npm >= 11.5.1 or run `npm install -g npm@latest`",
@@ -306,4 +321,4 @@ async function resolveProtocolsInPlace(pkg, packages, releasePlan, catalogs) {
 	}
 }
 //#endregion
-export { publishPackages as t };
+export { willUseOidcExclusively as n, publishPackages as t };

package/dist/{release-plan-mK7iGeGq.mjs → release-plan-C84pcBi-.mjs}

@@ -1,6 +1,6 @@
 import { i as __commonJSMin, s as __toESM } from "./logger-BgksGFuf.mjs";
-import { c as maxBump, l as normalizeCascadeConfig, n as DEFAULT_BUMP_RULES, o as bumpLevel, s as hasCascade } from "./types-Bkh-igOJ.mjs";
-import { s as matchGlob } from "./config-D_4GYDJi.mjs";
+import { c as maxBump, l as normalizeCascadeConfig, n as DEFAULT_BUMP_RULES, o as bumpLevel, s as hasCascade } from "./types-lpiG-Zxh.mjs";
+import { s as matchGlob } from "./config-0we4ISZX.mjs";
 //#region src/core/dep-graph.ts
 var DependencyGraph = class {
 	/** Map from package name → packages that depend on it */
@@ -1347,8 +1347,8 @@ var require_subset = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = subset;
 }));
 //#endregion
-//#region src/core/semver.ts
-var import_semver = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.bun/semver@7.7.4/node_modules/semver/index.js
+var require_semver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const internalRe = require_re();
 	const constants = require_constants();
 	const SemVer = require_semver$1();
@@ -1400,7 +1400,10 @@ var import_semver = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		compareIdentifiers: identifiers.compareIdentifiers,
 		rcompareIdentifiers: identifiers.rcompareIdentifiers
 	};
-})))(), 1);
+}));
+//#endregion
+//#region src/core/semver.ts
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
 function bumpVersion(version, type) {
 	const result = import_semver.default.inc(version, type);
 	if (!result) throw new Error(`Failed to bump ${version} by ${type}`);
@@ -1433,16 +1436,7 @@ function stripProtocol(range) {
 }
 //#endregion
 //#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) {
+function assembleReleasePlan(bumpFiles, packages, depGraph, config, opts = {}) {
 	if (bumpFiles.length === 0) return {
 		bumpFiles: [],
 		releases: [],
@@ -1485,11 +1479,12 @@ function assembleReleasePlan(bumpFiles, packages, depGraph, config) {
 		for (const [pkgName, bump] of planned) {
 			const pkg = packages.get(pkgName);
 			const newVersion = bumpVersion(pkg.version, bump.type);
+			const versionForRangeCheck = opts.prereleasePreid ? `${newVersion}-${opts.prereleasePreid}.0` : newVersion;
 			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;
+				if (satisfies(versionForRangeCheck, dep.versionRange, currentVersion)) continue;
 				let depBump;
 				if (dep.depType === "peerDependencies") depBump = bump.type;
 				else depBump = "patch";
@@ -1704,4 +1699,4 @@ function resolveRule(dependentName, depType, packages, config) {
 	};
 }
 //#endregion
-export { DependencyGraph as a, stripProtocol as i, bumpVersion as n, satisfies as r, assembleReleasePlan as t };
+export { require_semver as a, stripProtocol as i, bumpVersion as n, DependencyGraph as o, satisfies as r, assembleReleasePlan as t };

package/dist/status-CrMvvvNy.mjs

@@ -0,0 +1,232 @@
+import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
+import { a as loadConfig } from "./config-0we4ISZX.mjs";
+import { i as readBumpFiles, s as discoverPackages, t as filterBranchBumpFiles } from "./bump-file-mRJeReRJ.mjs";
+import { o as DependencyGraph, t as assembleReleasePlan } from "./release-plan-C84pcBi-.mjs";
+import { a as getChangedFiles, o as getCurrentBranch } from "./git-DAWj8LyV.mjs";
+import { channelNames, resolveActiveChannel } from "./channels-CFXZkyGd.mjs";
+import { t as buildChannelReleasePlan } from "./prerelease-Blnk8FE1.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 channel = resolveActiveChannel(rootDir, config, opts.channel);
+	if (channel) {
+		await channelStatus(rootDir, config, channel, packages, depGraph, opts);
+		return;
+	}
+	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
+	if (parseErrors.length > 0) for (const err of parseErrors) log.error(err);
+	if (bumpFiles.length === 0) {
+		if (opts.json) console.log(JSON.stringify({
+			bumpFiles: [],
+			releases: [],
+			packageNames: []
+		}, null, 2));
+		else if (!opts.packagesOnly) log.info("No pending bump files.");
+		process.exit(1);
+	}
+	const plan = assembleReleasePlan(bumpFiles, packages, depGraph, config);
+	let branchBumpFileIds;
+	const currentBranch = getCurrentBranch({ cwd: rootDir });
+	if (currentBranch && currentBranch !== config.baseBranch) branchBumpFileIds = filterBranchBumpFiles(bumpFiles, getChangedFiles(rootDir, config.baseBranch), rootDir).branchBumpFileIds;
+	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-0we4ISZX.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 = {
+			bumpFiles: plan.bumpFiles.map((bf) => ({
+				id: bf.id,
+				summary: bf.summary,
+				releases: bf.releases.map((r) => ({
+					name: r.name,
+					type: r.type
+				})),
+				...branchBumpFileIds ? { inCurrentBranch: branchBumpFileIds.has(bf.id) } : {}
+			})),
+			releases: releases.map((r) => {
+				const pkg = packages.get(r.name);
+				const pkgConfig = pkg?.bumpy || {};
+				return {
+					name: r.name,
+					type: r.type,
+					oldVersion: r.oldVersion,
+					newVersion: r.newVersion,
+					dir: pkg?.relativeDir,
+					bumpFiles: r.bumpFiles,
+					isDependencyBump: r.isDependencyBump,
+					isCascadeBump: r.isCascadeBump,
+					...branchBumpFileIds ? { inCurrentBranch: r.bumpFiles.some((id) => branchBumpFileIds.has(id)) } : {},
+					publishTargets: getPublishTargets(pkg, pkgConfig, config)
+				};
+			}),
+			packageNames: releases.map((r) => r.name)
+		};
+		console.log(JSON.stringify(jsonOutput, null, 2));
+		return;
+	}
+	if (opts.packagesOnly) {
+		for (const r of releases) console.log(r.name);
+		return;
+	}
+	log.bold(`${bumpFiles.length} bump file(s) pending\n`);
+	if (releases.length === 0) {
+		log.warn("No packages match the current filters.");
+		return;
+	}
+	const groups = [
+		[
+			"Major",
+			"red",
+			releases.filter((r) => r.type === "major")
+		],
+		[
+			"Minor",
+			"yellow",
+			releases.filter((r) => r.type === "minor")
+		],
+		[
+			"Patch",
+			"green",
+			releases.filter((r) => r.type === "patch")
+		]
+	];
+	for (const [label, color, group] of groups) {
+		if (group.length === 0) continue;
+		log.bold(colorize(label, color));
+		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("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")}`);
+		}
+	}
+}
+/**
+* Status on a prerelease channel: shows the cycle (shipped + pending bump files)
+* and the derived prerelease versions. Counters come from the registry — when it's
+* unreachable, targets render with a ".?" counter placeholder.
+*/
+async function channelStatus(rootDir, config, channel, packages, depGraph, opts) {
+	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
+	for (const err of parseErrors) log.error(err);
+	const shipped = bumpFiles.filter((bf) => bf.channel === channel.name);
+	const pending = bumpFiles.filter((bf) => bf.channel !== channel.name);
+	if (bumpFiles.length === 0) {
+		if (opts.json) console.log(JSON.stringify({
+			channel: channel.name,
+			bumpFiles: [],
+			releases: [],
+			packageNames: []
+		}, null, 2));
+		else if (!opts.packagesOnly) log.info(`No bump files in the "${channel.name}" cycle.`);
+		process.exit(1);
+	}
+	const stablePlan = assembleReleasePlan(bumpFiles, packages, depGraph, config, { prereleasePreid: channel.preid });
+	let releases = stablePlan.releases;
+	let countersExact = false;
+	try {
+		const built = await buildChannelReleasePlan(stablePlan, channel, packages, rootDir, { forDisplay: true });
+		if (built.plan.releases.length > 0) {
+			releases = built.plan.releases;
+			countersExact = true;
+		}
+	} catch {}
+	if (!countersExact) releases = releases.map((r) => ({
+		...r,
+		newVersion: `${r.newVersion}-${channel.preid}.?`
+	}));
+	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-0we4ISZX.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) {
+		console.log(JSON.stringify({
+			channel: channel.name,
+			preid: channel.preid,
+			tag: channel.tag,
+			bumpFiles: bumpFiles.map((bf) => ({
+				id: bf.id,
+				summary: bf.summary,
+				releases: bf.releases.map((r) => ({
+					name: r.name,
+					type: r.type
+				})),
+				shipped: bf.channel === channel.name
+			})),
+			releases: releases.map((r) => {
+				const pkg = packages.get(r.name);
+				return {
+					name: r.name,
+					type: r.type,
+					oldVersion: r.oldVersion,
+					newVersion: r.newVersion,
+					dir: pkg?.relativeDir,
+					bumpFiles: r.bumpFiles,
+					isDependencyBump: r.isDependencyBump,
+					isCascadeBump: r.isCascadeBump,
+					publishTargets: getPublishTargets(pkg, pkg?.bumpy || {}, config)
+				};
+			}),
+			packageNames: releases.map((r) => r.name)
+		}, null, 2));
+		return;
+	}
+	if (opts.packagesOnly) {
+		for (const r of releases) console.log(r.name);
+		return;
+	}
+	log.bold(`Channel "${channel.name}" — preid "-${channel.preid}.N", dist-tag @${channel.tag}\n`);
+	printBumpFileGroup(`Shipped on this channel (.bumpy/${channel.name}/)`, shipped);
+	printBumpFileGroup("Pending (next prerelease)", pending);
+	log.bold(`Cycle releases${countersExact ? "" : colorize(" (registry unreachable — counters unknown)", "dim")}`);
+	for (const r of releases) printRelease(r, packages);
+	console.log();
+	if (stablePlan.warnings.length > 0) for (const w of stablePlan.warnings) log.warn(w);
+}
+function printBumpFileGroup(label, files) {
+	log.bold(label);
+	if (files.length === 0) console.log(colorize("  (none)", "dim"));
+	for (const bf of files) {
+		const summary = bf.summary ? colorize(` — ${bf.summary.split("\n")[0]}`, "dim") : "";
+		console.log(`  ${colorize(`${bf.id}.md`, "cyan")}${summary}`);
+	}
+	console.log();
+}
+function printRelease(r, packages) {
+	const pkg = packages.get(r.name);
+	const dir = pkg ? colorize(` (${pkg.relativeDir})`, "dim") : "";
+	const suffix = r.isDependencyBump ? colorize(" ← dependency bump", "dim") : r.isCascadeBump ? colorize(" ← cascade", "dim") : "";
+	console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(r.newVersion, "cyan")}${suffix}${dir}`);
+}
+/** Determine which publish targets a package will use */
+function getPublishTargets(pkg, pkgConfig, _config) {
+	if (!pkg) return [];
+	if (pkg.private && !pkgConfig.publishCommand) return [];
+	const targets = [];
+	if (pkgConfig.publishCommand) targets.push({ type: "custom" });
+	if (!pkgConfig.publishCommand && !pkgConfig.skipNpmPublish) targets.push({ type: "npm" });
+	return targets;
+}
+//#endregion
+export { statusCommand };

package/dist/{types-Bkh-igOJ.mjs → types-lpiG-Zxh.mjs}

@@ -56,6 +56,7 @@ const DEFAULT_PUBLISH_CONFIG = {
 const DEFAULT_CONFIG = {
 	baseBranch: "main",
 	access: "public",
+	channels: {},
 	versionCommitMessage: void 0,
 	changedFilePatterns: ["**"],
 	changelog: "default",