@varlock/bumpy 1.13.2 → 1.14.0-rc.1

package/dist/{ci-B7gF6CFP.mjs → ci-ChYmDuwy.mjs}

@@ -1,13 +1,15 @@
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
-import { a as loadConfig } from "./config-D_4GYDJi.mjs";
+import { a as loadConfig } from "./config-0we4ISZX.mjs";
 import { n as detectPackageManager } from "./package-manager-Db_vTztt.mjs";
-import { i as recoverDeletedBumpFiles, r as readBumpFiles, s as discoverWorkspace, t as filterBranchBumpFiles } from "./bump-file-B7hmXZlB.mjs";
-import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-mK7iGeGq.mjs";
+import { a as recoverDeletedBumpFiles, c as discoverWorkspace, i as readBumpFiles, t as filterBranchBumpFiles } from "./bump-file-mRJeReRJ.mjs";
+import { o as DependencyGraph, t as assembleReleasePlan } from "./release-plan-C84pcBi-.mjs";
 import { n as runArgs, r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { a as getChangedFiles, f as withGitToken } from "./git-BWPimLgc.mjs";
+import { a as getChangedFiles, p as withGitToken } from "./git-DAWj8LyV.mjs";
 import { t as randomName } from "./names-COooXAFg.mjs";
-import { n as findChangedPackages } from "./check-Dvi0DIqC.mjs";
-import { t as resolveCommitMessage } from "./commit-message-CSWVKPJ-.mjs";
+import { n as findChangedPackages } from "./check-DIl9Dz68.mjs";
+import { channelNames, detectReleaseBranch, matchChannelByBranch, resolveChannels } from "./channels-CFXZkyGd.mjs";
+import { n as channelDisplayPlan, r as formatChannelVersionSummary, t as buildChannelReleasePlan } from "./prerelease-B2PVfXkm.mjs";
+import { t as resolveCommitMessage } from "./commit-message-BwsowSds.mjs";
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 //#region src/commands/ci.ts
@@ -76,15 +78,19 @@ async function ciCheckCommand(rootDir, opts) {
 	const { packages } = await discoverWorkspace(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
 	const { bumpFiles: allBumpFiles, errors: parseErrors } = await readBumpFiles(rootDir);
-	if (detectPrBranch(rootDir) === config.versionPr.branch) {
-		log.dim("  Skipping — this is the version PR branch.");
+	const prBranchName = detectPrBranch(rootDir);
+	const releasePrBranches = new Set([config.versionPr.branch, ...[...resolveChannels(config).values()].map((c) => c.versionPr.branch)]);
+	if (prBranchName && releasePrBranches.has(prBranchName)) {
+		log.dim("  Skipping — this is a release PR branch.");
 		return;
 	}
 	const inCI = !!process.env.CI;
 	const shouldComment = opts.comment ?? inCI;
 	const prNumber = detectPrNumber();
 	const pm = await detectPackageManager(rootDir);
-	const changedFiles = getChangedFiles(rootDir, config.baseBranch);
+	const compareBranch = process.env.GITHUB_BASE_REF || config.baseBranch;
+	const prChannel = matchChannelByBranch(config, process.env.GITHUB_BASE_REF || null);
+	const changedFiles = getChangedFiles(rootDir, compareBranch);
 	const { branchBumpFiles: prBumpFiles, emptyBumpFileIds } = filterBranchBumpFiles(allBumpFiles, changedFiles, rootDir, parseErrors);
 	if (parseErrors.length > 0) for (const err of parseErrors) log.error(err);
 	if (prBumpFiles.length === 0) {
@@ -108,14 +114,15 @@ async function ciCheckCommand(rootDir, opts) {
 		if (willFail) process.exit(1);
 		return;
 	}
-	const plan = assembleReleasePlan(prBumpFiles, packages, depGraph, config);
-	log.bold(`${prBumpFiles.length} bump file(s) → ${plan.releases.length} package(s) to release\n`);
+	const plan = assembleReleasePlan(prBumpFiles, packages, depGraph, config, prChannel ? { prereleasePreid: prChannel.preid } : {});
+	const releaseSuffix = prChannel ? `-${prChannel.preid}.x` : "";
+	log.bold(`${prBumpFiles.length} bump file(s) → ${plan.releases.length} package(s) to release${prChannel ? ` on the "${prChannel.name}" channel (@${prChannel.tag})` : ""}\n`);
 	for (const r of plan.releases) {
 		const tag = r.isDependencyBump ? " (dep)" : r.isCascadeBump ? " (cascade)" : "";
-		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(r.newVersion, "cyan")}${tag}`);
+		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(`${r.newVersion}${releaseSuffix}`, "cyan")}${tag}`);
 	}
 	if (plan.warnings.length > 0) for (const w of plan.warnings) log.warn(w);
-	if (shouldComment && prNumber) await postOrUpdatePrComment(prNumber, formatReleasePlanComment(plan, prBumpFiles, prNumber, detectPrBranch(rootDir), pm, plan.warnings, parseErrors, emptyBumpFileIds), rootDir);
+	if (shouldComment && prNumber) await postOrUpdatePrComment(prNumber, formatReleasePlanComment(plan, prBumpFiles, prNumber, detectPrBranch(rootDir), pm, plan.warnings, parseErrors, emptyBumpFileIds, prChannel), rootDir);
 	if (parseErrors.length > 0 && !opts.noFail) process.exit(1);
 	const coveredPackages = new Set(plan.releases.map((r) => r.name));
 	for (const bf of prBumpFiles) for (const release of bf.releases) coveredPackages.add(release.name);
@@ -136,11 +143,16 @@ async function ciPlanCommand(rootDir) {
 	const config = await loadConfig(rootDir);
 	const { packages } = await discoverWorkspace(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
-	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir);
+	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
 	if (parseErrors.length > 0) {
 		for (const err of parseErrors) log.error(err);
 		throw new Error("Bump file parse errors must be fixed before planning.");
 	}
+	const channel = matchChannelByBranch(config, detectReleaseBranch(rootDir));
+	if (channel) {
+		await ciChannelPlan(rootDir, config, channel, packages, depGraph, bumpFiles);
+		return;
+	}
 	let output;
 	const plan = bumpFiles.length > 0 ? assembleReleasePlan(bumpFiles, packages, depGraph, config) : null;
 	if (plan && plan.releases.length > 0) output = {
@@ -157,7 +169,7 @@ async function ciPlanCommand(rootDir) {
 		packageNames: plan.releases.map((r) => r.name)
 	};
 	else {
-		const { findUnpublishedPackages } = await import("./publish-VYBhDYFM.mjs");
+		const { findUnpublishedPackages } = await import("./publish-Ak6jmwi_.mjs");
 		const unpublished = await findUnpublishedPackages(packages, config);
 		if (unpublished.length > 0) output = {
 			mode: "publish",
@@ -220,9 +232,16 @@ function writeGitHubOutput(key, value) {
 async function ciReleaseCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
 	ensureGitIdentity(rootDir, config);
+	const releaseBranch = detectReleaseBranch(rootDir);
+	const channel = matchChannelByBranch(config, releaseBranch);
+	if (channel) {
+		await ciChannelRelease(rootDir, config, channel, opts);
+		return;
+	}
+	if (Object.keys(config.channels || {}).length > 0 && releaseBranch && releaseBranch !== config.baseBranch) throw new Error(`"bumpy ci release" ran on branch "${releaseBranch}", which is neither the base branch ("${config.baseBranch}") nor a configured channel branch. Refusing to release — add the branch to "channels" in .bumpy/_config.json or fix the workflow trigger.`);
 	const { packages } = await discoverWorkspace(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
-	const { bumpFiles, errors: releaseParseErrors } = await readBumpFiles(rootDir);
+	const { bumpFiles, errors: releaseParseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
 	if (releaseParseErrors.length > 0) {
 		for (const err of releaseParseErrors) log.error(err);
 		throw new Error("Bump file parse errors must be fixed before releasing.");
@@ -234,7 +253,7 @@ async function ciReleaseCommand(rootDir, opts) {
 		const msg = bumpFiles.length === 0 ? "No pending bump files — checking for unpublished packages..." : "Bump files found but no packages would be released — checking for unpublished packages...";
 		log.info(msg);
 		const recoveredBumpFiles = recoverDeletedBumpFiles(rootDir);
-		const { publishCommand } = await import("./publish-VYBhDYFM.mjs");
+		const { publishCommand } = await import("./publish-Ak6jmwi_.mjs");
 		await publishCommand(rootDir, {
 			tag: opts.tag,
 			recoveredBumpFiles
@@ -258,7 +277,7 @@ async function ciReleaseCommand(rootDir, opts) {
 */
 async function autoPublish(rootDir, config, plan, tag) {
 	log.step("Running bumpy version...");
-	const { versionCommand } = await import("./version-Cm0nRAFF.mjs");
+	const { versionCommand } = await import("./version-CMJUopVj.mjs");
 	await versionCommand(rootDir);
 	log.step("Committing version changes...");
 	runArgs([
@@ -287,7 +306,7 @@ async function autoPublish(rootDir, config, plan, tag) {
 		], { cwd: rootDir });
 	}
 	log.step("Running bumpy publish...");
-	const { publishCommand } = await import("./publish-VYBhDYFM.mjs");
+	const { publishCommand } = await import("./publish-Ak6jmwi_.mjs");
 	await publishCommand(rootDir, { tag });
 }
 /**
@@ -361,7 +380,7 @@ async function createVersionPr(rootDir, plan, config, packageDirs, branchName) {
 		branch
 	], { cwd: rootDir });
 	log.step("Running bumpy version...");
-	const { versionCommand } = await import("./version-Cm0nRAFF.mjs");
+	const { versionCommand } = await import("./version-CMJUopVj.mjs");
 	await versionCommand(rootDir);
 	runArgs([
 		"git",
@@ -457,6 +476,332 @@ async function createVersionPr(rootDir, plan, config, packageDirs, branchName) {
 		baseBranch
 	], { cwd: rootDir });
 }
+/** Read the push event's before/after range, if running on a GitHub Actions push event */
+function getPushEventRange() {
+	if (process.env.GITHUB_EVENT_NAME !== "push") return null;
+	const path = process.env.GITHUB_EVENT_PATH;
+	if (!path) return null;
+	try {
+		const payload = JSON.parse(readFileSync(path, "utf-8"));
+		if (payload.before && payload.after && !/^0+$/.test(payload.before)) return {
+			before: payload.before,
+			after: payload.after
+		};
+	} catch {}
+	return null;
+}
+/**
+* Bump file IDs added to `.bumpy/<channel>/` by the push that triggered this run.
+*
+* This is the channel publish trigger: merging the release PR moves files into the
+* channel dir; ordinary feature merges don't touch it. Re-running on the same push is
+* idempotent — packages already published from this commit are skipped via the
+* gitHead recorded on the registry.
+*/
+function detectChannelMoves(rootDir, channel) {
+	const range = getPushEventRange();
+	let diffRange;
+	if (range) diffRange = `${range.before}..${range.after}`;
+	else {
+		if (!tryRunArgs([
+			"git",
+			"rev-parse",
+			"--verify",
+			"HEAD^"
+		], { cwd: rootDir })) {
+			log.warn("Cannot diff against the previous commit (shallow clone?) — channel publish trigger unavailable.\n  Use `fetch-depth: 0` in your checkout step, or run `bumpy publish` manually on the channel branch.");
+			return [];
+		}
+		diffRange = "HEAD^..HEAD";
+	}
+	const out = tryRunArgs([
+		"git",
+		"diff",
+		"--name-only",
+		"--diff-filter=A",
+		"--no-renames",
+		diffRange,
+		"--",
+		`.bumpy/${channel.name}/`
+	], { cwd: rootDir });
+	if (!out) return [];
+	return out.split("\n").filter((f) => f.endsWith(".md") && !f.endsWith("README.md")).map((f) => f.split("/").pop().replace(/\.md$/, ""));
+}
+/**
+* CI release on a channel branch. Two independent steps, both of which can run
+* in the same invocation:
+*
+* 1. **Publish** — if this push moved bump files into `.bumpy/<channel>/` (a release
+*    PR merge), publish the cycle as prereleases. Versions are derived (targets from
+*    bump files, counters from the registry) and never committed.
+* 2. **Release PR** — if pending bump files exist (root or other channels' dirs),
+*    create/update the file-move release PR.
+*/
+async function ciChannelRelease(rootDir, config, channel, opts) {
+	log.bold(`Channel "${channel.name}" (branch "${channel.branch}")\n`);
+	const { packages } = await discoverWorkspace(rootDir, config);
+	const { bumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
+	if (parseErrors.length > 0) {
+		for (const err of parseErrors) log.error(err);
+		throw new Error("Bump file parse errors must be fixed before releasing.");
+	}
+	const pending = bumpFiles.filter((bf) => bf.channel !== channel.name);
+	if (opts.autoPublish) {
+		if (pending.length > 0) {
+			const { channelVersion } = await import("./version-CMJUopVj.mjs");
+			if (await channelVersion(rootDir, config, channel, { commit: true })) runArgs([
+				"git",
+				"push",
+				"--no-verify"
+			], { cwd: rootDir });
+		}
+		const { publishCommand } = await import("./publish-Ak6jmwi_.mjs");
+		await publishCommand(rootDir, {
+			channel: channel.name,
+			tag: opts.tag
+		});
+		return;
+	}
+	const movedIds = detectChannelMoves(rootDir, channel);
+	const shouldPublish = movedIds.length > 0 && opts.assertMode !== "version-pr";
+	if (shouldPublish) {
+		log.step(`Release PR merge detected (${movedIds.map((id) => `${id}.md`).join(", ")}) — publishing prereleases...`);
+		const { publishCommand } = await import("./publish-Ak6jmwi_.mjs");
+		await publishCommand(rootDir, {
+			channel: channel.name,
+			tag: opts.tag
+		});
+	}
+	if (opts.assertMode === "publish") {
+		if (!shouldPublish) throw new Error("Expected mode \"publish\" but this push did not move bump files into the channel dir. Either remove --expect-mode, or gate this step on the output of \"bumpy ci plan\".");
+		return;
+	}
+	if (pending.length > 0) await createChannelReleasePr(rootDir, config, channel, packages, opts.branch);
+	else if (!shouldPublish) log.info(`Nothing to do on channel "${channel.name}" — no pending bump files, no release PR merge in this push.`);
+}
+/**
+* Create or update the channel's release PR. Unlike the stable version PR, its diff
+* is pure file moves (pending bump files → `.bumpy/<channel>/`) — no versions, no
+* changelogs. The PR title/body show targets with a wildcard counter (`1.2.0-rc.x`),
+* derived purely from committed state; the exact counter is assigned at publish time.
+*/
+async function createChannelReleasePr(rootDir, config, channel, packages, branchOverride) {
+	const branch = validateBranchName(branchOverride || channel.versionPr.branch);
+	const baseBranch = validateBranchName(channel.branch);
+	const existingPr = tryRunArgs([
+		"gh",
+		"pr",
+		"list",
+		"--head",
+		branch,
+		"--json",
+		"number",
+		"--jq",
+		".[0].number"
+	], { cwd: rootDir });
+	log.step(`Creating branch ${branch}...`);
+	if (tryRunArgs([
+		"git",
+		"rev-parse",
+		"--verify",
+		branch
+	], { cwd: rootDir }) !== null) {
+		runArgs([
+			"git",
+			"checkout",
+			branch
+		], { cwd: rootDir });
+		runArgs([
+			"git",
+			"reset",
+			"--hard",
+			baseBranch
+		], { cwd: rootDir });
+	} else runArgs([
+		"git",
+		"checkout",
+		"-b",
+		branch
+	], { cwd: rootDir });
+	const { channelVersion } = await import("./version-CMJUopVj.mjs");
+	const result = await channelVersion(rootDir, config, channel);
+	if (!result) {
+		log.info("No pending bump files to move.");
+		runArgs([
+			"git",
+			"checkout",
+			baseBranch
+		], { cwd: rootDir });
+		return;
+	}
+	const displayPlan = channelDisplayPlan(result.cyclePlan, channel, packages);
+	const versionSummary = formatChannelVersionSummary(displayPlan.releases);
+	const prTitle = versionSummary ? `${channel.versionPr.title}: ${versionSummary}` : channel.versionPr.title;
+	runArgs([
+		"git",
+		"add",
+		"-A",
+		".bumpy/"
+	], { cwd: rootDir });
+	if (!tryRunArgs([
+		"git",
+		"status",
+		"--porcelain"
+	], { cwd: rootDir })) {
+		log.info("No changes to commit.");
+		runArgs([
+			"git",
+			"checkout",
+			baseBranch
+		], { cwd: rootDir });
+		return;
+	}
+	runArgs([
+		"git",
+		"commit",
+		"-F",
+		"-"
+	], {
+		cwd: rootDir,
+		input: `${prTitle}\n\nShipped: ${result.movedFiles.map((bf) => `${bf.id}.md`).join(", ")}`
+	});
+	pushWithToken(rootDir, branch, config);
+	const repo = process.env.GITHUB_REPOSITORY;
+	const noPatWarning = !process.env.BUMPY_GH_TOKEN && !!repo;
+	const packageDirs = new Map([...packages.values()].map((p) => [p.name, p.relativeDir]));
+	const preamble = buildChannelPrPreamble(config, channel);
+	let prNumber = null;
+	if (existingPr) {
+		prNumber = validatePrNumber(existingPr);
+		const prBody = formatVersionPrBody(displayPlan, preamble, packageDirs, repo, prNumber, noPatWarning);
+		log.step(`Updating existing PR #${prNumber}...`);
+		await withPatToken(() => runArgsAsync([
+			"gh",
+			"pr",
+			"edit",
+			prNumber,
+			"--title",
+			prTitle,
+			"--body-file",
+			"-"
+		], {
+			cwd: rootDir,
+			input: prBody
+		}));
+		log.success(`🐸 Updated PR #${prNumber}`);
+	} else {
+		log.step("Creating release PR...");
+		const prBody = formatVersionPrBody(displayPlan, preamble, packageDirs, repo, null, noPatWarning);
+		const createResult = await withPatToken(() => runArgsAsync([
+			"gh",
+			"pr",
+			"create",
+			"--title",
+			prTitle,
+			"--body-file",
+			"-",
+			"--base",
+			baseBranch,
+			"--head",
+			branch
+		], {
+			cwd: rootDir,
+			input: prBody
+		}));
+		log.success(`🐸 Created PR: ${createResult}`);
+		prNumber = createResult?.match(/\/pull\/(\d+)/)?.[1] ?? null;
+		if (repo && prNumber) {
+			const updatedBody = formatVersionPrBody(displayPlan, preamble, packageDirs, repo, prNumber, noPatWarning);
+			await withPatToken(() => runArgsAsync([
+				"gh",
+				"pr",
+				"edit",
+				prNumber,
+				"--body-file",
+				"-"
+			], {
+				cwd: rootDir,
+				input: updatedBody
+			}));
+		}
+		if (!process.env.BUMPY_GH_TOKEN) pushWithToken(rootDir, branch, config);
+	}
+	if (channel.versionPr.automerge && prNumber) await enableAutoMerge(rootDir, prNumber);
+	runArgs([
+		"git",
+		"checkout",
+		baseBranch
+	], { cwd: rootDir });
+}
+function buildChannelPrPreamble(config, channel) {
+	return [
+		config.versionPr.preamble,
+		"",
+		`> 🔀 **Prerelease channel \`${channel.name}\`** — merging this PR publishes the versions below to the \`@${channel.tag}\` dist-tag.`,
+		`> The diff only moves bump files into \`.bumpy/${channel.name}/\` — prerelease versions are derived at publish time and never committed. The \`.x\` counter is assigned from the registry at publish time.`
+	].join("\n");
+}
+/** Enable GitHub auto-merge on a PR, trying the available merge methods in order */
+async function enableAutoMerge(rootDir, prNumber) {
+	const validPr = validatePrNumber(prNumber);
+	for (const method of [
+		"--squash",
+		"--merge",
+		"--rebase"
+	]) try {
+		await withPatToken(() => runArgsAsync([
+			"gh",
+			"pr",
+			"merge",
+			validPr,
+			"--auto",
+			method
+		], { cwd: rootDir }));
+		log.dim(`  Auto-merge enabled (${method.slice(2)})`);
+		return;
+	} catch {}
+	log.warn("  Failed to enable auto-merge — check repository merge settings and token permissions.");
+}
+/** Channel-aware `ci plan`: reports what `ci release` would do on this channel branch */
+async function ciChannelPlan(rootDir, config, channel, packages, depGraph, bumpFiles) {
+	const pending = bumpFiles.filter((bf) => bf.channel !== channel.name);
+	const movedIds = detectChannelMoves(rootDir, channel);
+	let mode = "nothing";
+	let releases = [];
+	if (pending.length > 0 || movedIds.length > 0) {
+		mode = pending.length > 0 ? "version-pr" : "publish";
+		const stablePlan = assembleReleasePlan(bumpFiles, packages, depGraph, config, { prereleasePreid: channel.preid });
+		try {
+			releases = (await buildChannelReleasePlan(stablePlan, channel, packages, rootDir, { forDisplay: true })).plan.releases;
+		} catch {
+			releases = stablePlan.releases.map((r) => ({
+				...r,
+				newVersion: `${r.newVersion}-${channel.preid}.?`
+			}));
+		}
+	}
+	const output = {
+		mode,
+		channel: channel.name,
+		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) => formatPlanRelease(r, packages, config)),
+		packageNames: releases.map((r) => r.name)
+	};
+	const json = JSON.stringify(output, null, 2);
+	console.log(json);
+	writeGitHubOutput("mode", output.mode);
+	writeGitHubOutput("channel", channel.name);
+	writeGitHubOutput("packages", JSON.stringify(output.packageNames));
+	writeGitHubOutput("json", JSON.stringify(output));
+}
 const FROG_IMG_BASE = "https://raw.githubusercontent.com/dmno-dev/bumpy/main/images";
 function buildAddBumpFileLink(prBranch) {
 	if (!prBranch) return null;
@@ -479,13 +824,15 @@ function pmRunCommand(pm) {
 	if (pm === "yarn") return "yarn bumpy";
 	return "npx bumpy";
 }
-function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warnings = [], parseErrors = [], emptyBumpFileIds = []) {
+function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warnings = [], parseErrors = [], emptyBumpFileIds = [], channel = null) {
 	const repo = process.env.GITHUB_REPOSITORY;
 	const lines = [];
+	const versionSuffix = channel ? `-${channel.preid}.x` : "";
+	const headline = channel ? `**This PR targets the \`${channel.name}\` prerelease channel** — merging it ships these packages as a **prerelease** to the \`@${channel.tag}\` dist-tag, not a stable release.` : "**The changes in this PR will be included in the next version bump.**";
 	const preamble = [
 		`<a href="https://bumpy.varlock.dev"><img src="${FROG_IMG_BASE}/frog-clipboard.png" alt="bumpy-frog" width="60" align="left" style="image-rendering: pixelated;" title="Hi! I'm bumpy!" /></a>`,
 		"",
-		"**The changes in this PR will be included in the next version bump.**",
+		headline,
 		"<br clear=\"left\" />"
 	].join("\n");
 	lines.push(preamble);
@@ -507,10 +854,16 @@ function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warni
 		lines.push("");
 		for (const r of releases) {
 			const suffix = r.isDependencyBump ? " _(dep)_" : r.isCascadeBump ? " _(cascade)_" : "";
-			lines.push(`- \`${r.name}\` ${r.oldVersion} → **${r.newVersion}**${suffix}`);
+			lines.push(`- \`${r.name}\` ${r.oldVersion} → **${r.newVersion}${versionSuffix}**${suffix}`);
 		}
 		lines.push("");
 	}
+	if (channel) {
+		const examplePkg = plan.releases.find((r) => !r.isDependencyBump && !r.isCascadeBump)?.name ?? plan.releases[0]?.name;
+		const installHint = examplePkg ? ` (e.g. \`npm i ${examplePkg}@${channel.tag}\`)` : "";
+		lines.push(`> 🔀 Published to the \`@${channel.tag}\` dist-tag${installHint}. Prerelease versions are derived at publish time — the \`.x\` counter is filled in from the registry. Promote to a stable release by merging \`${channel.branch}\` into your base branch.`);
+		lines.push("");
+	}
 	lines.push(`#### Bump files in this PR`);
 	lines.push("");
 	for (const bf of bumpFiles) {

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
-import { n as findRoot } from "./config-D_4GYDJi.mjs";
+import { n as findRoot } from "./config-0we4ISZX.mjs";
 //#region src/cli.ts
 const args = process.argv.slice(2);
 const command = args[0];
@@ -25,13 +25,13 @@ async function main() {
 		switch (command) {
 			case "init": {
 				const rootDir = await findRoot();
-				const { initCommand } = await import("./init-BCkm6Nfa.mjs");
+				const { initCommand } = await import("./init-DkAY5hjc.mjs");
 				await initCommand(rootDir, { force: flags.force === true });
 				break;
 			}
 			case "add": {
 				const rootDir = await findRoot();
-				const { addCommand } = await import("./add-Dt1hddMt.mjs");
+				const { addCommand } = await import("./add-C9rU_89s.mjs");
 				await addCommand(rootDir, {
 					packages: flags.packages,
 					message: flags.message,
@@ -43,25 +43,29 @@ async function main() {
 			}
 			case "status": {
 				const rootDir = await findRoot();
-				const { statusCommand } = await import("./status-DxzKPM8d.mjs");
+				const { statusCommand } = await import("./status-DIzi-Iai.mjs");
 				await statusCommand(rootDir, {
 					json: flags.json === true,
 					packagesOnly: flags.packages === true,
 					bumpType: flags.bump,
 					filter: flags.filter,
-					verbose: flags.verbose === true
+					verbose: flags.verbose === true,
+					channel: flags.channel
 				});
 				break;
 			}
 			case "version": {
 				const rootDir = await findRoot();
-				const { versionCommand } = await import("./version-Cm0nRAFF.mjs");
-				await versionCommand(rootDir, { commit: flags.commit === true });
+				const { versionCommand } = await import("./version-CMJUopVj.mjs");
+				await versionCommand(rootDir, {
+					commit: flags.commit === true,
+					channel: flags.channel
+				});
 				break;
 			}
 			case "generate": {
 				const rootDir = await findRoot();
-				const { generateCommand } = await import("./generate-DohUlhu3.mjs");
+				const { generateCommand } = await import("./generate-B2OMt_64.mjs");
 				await generateCommand(rootDir, {
 					from: flags.from,
 					dryRun: flags["dry-run"] === true,
@@ -71,7 +75,7 @@ async function main() {
 			}
 			case "check": {
 				const rootDir = await findRoot();
-				const { checkCommand } = await import("./check-Dvi0DIqC.mjs").then((n) => n.t);
+				const { checkCommand } = await import("./check-DIl9Dz68.mjs").then((n) => n.t);
 				const hookValue = flags.hook;
 				if (hookValue && hookValue !== "pre-commit" && hookValue !== "pre-push") {
 					log.error(`Invalid --hook value "${hookValue}". Expected "pre-commit" or "pre-push".`);
@@ -80,7 +84,8 @@ async function main() {
 				await checkCommand(rootDir, {
 					strict: flags.strict === true,
 					noFail: flags["no-fail"] === true,
-					hook: hookValue
+					hook: hookValue,
+					base: flags.base
 				});
 				break;
 			}
@@ -89,17 +94,17 @@ async function main() {
 				const subcommand = args[1];
 				const ciFlags = parseFlags(args.slice(2));
 				if (subcommand === "check") {
-					const { ciCheckCommand } = await import("./ci-B7gF6CFP.mjs");
+					const { ciCheckCommand } = await import("./ci-ChYmDuwy.mjs");
 					await ciCheckCommand(rootDir, {
 						comment: ciFlags.comment !== void 0 ? ciFlags.comment === true : void 0,
 						strict: ciFlags.strict === true,
 						noFail: ciFlags["no-fail"] === true
 					});
 				} else if (subcommand === "plan") {
-					const { ciPlanCommand } = await import("./ci-B7gF6CFP.mjs");
+					const { ciPlanCommand } = await import("./ci-ChYmDuwy.mjs");
 					await ciPlanCommand(rootDir);
 				} else if (subcommand === "release") {
-					const { ciReleaseCommand } = await import("./ci-B7gF6CFP.mjs");
+					const { ciReleaseCommand } = await import("./ci-ChYmDuwy.mjs");
 					const expectModeFlag = ciFlags["expect-mode"];
 					const autoPublishFlag = ciFlags["auto-publish"] === true;
 					if (expectModeFlag !== void 0 && expectModeFlag !== "version-pr" && expectModeFlag !== "publish") {
@@ -127,12 +132,13 @@ async function main() {
 			}
 			case "publish": {
 				const rootDir = await findRoot();
-				const { publishCommand } = await import("./publish-VYBhDYFM.mjs");
+				const { publishCommand } = await import("./publish-Ak6jmwi_.mjs");
 				await publishCommand(rootDir, {
 					dryRun: flags["dry-run"] === true,
 					tag: flags.tag,
 					noPush: flags["no-push"] === true,
-					filter: flags.filter
+					filter: flags.filter,
+					channel: flags.channel
 				});
 				break;
 			}
@@ -186,8 +192,11 @@ function printHelp() {
       --strict                Fail if any changed package is uncovered (default: only fail if no bump files at all)
       --no-fail               Warn only, never exit 1
       --hook <context>        Hook context: "pre-commit" or "pre-push" (controls which bump files count)
+      --base <branch>         Branch to compare against (default: baseBranch; use the channel branch for channel PRs)
     version [--commit]      Apply bump files and bump versions
+                            (on a channel branch: moves pending bump files into .bumpy/<channel>/)
     publish                 Publish versioned packages
+                            (on a channel branch: derives prerelease versions and publishes to the channel dist-tag)
     ci check                PR check — report pending releases, comment on PR
     ci plan                 Report what ci release would do (JSON + GitHub Actions outputs)
     ci release              Release — create version PR or auto-publish
@@ -211,12 +220,18 @@ function printHelp() {
     --bump <types>          Filter by bump type (e.g., "major", "minor,patch")
     --filter <names>        Filter by package name/glob (e.g., "@myorg/*")
     --verbose               Show bump file details
+    --channel <name>        Show channel status (default: inferred from the current branch)
 
   Publish options:
     --dry-run               Preview without publishing
     --tag <tag>             npm dist-tag (e.g., "next", "beta")
     --no-push               Skip pushing git tags to remote
     --filter <names>        Publish only matching packages (e.g., "@myorg/*")
+    --channel <name>        Publish a prerelease channel (default: inferred from the current branch)
+
+  Version options:
+    --commit                Create a git commit with the version changes
+    --channel <name>        Channel override (default: inferred from the current branch)
 
   CI check options:
     --comment               Force PR comment on/off (auto-detected in CI)

package/dist/{config-D_4GYDJi.mjs → config-0we4ISZX.mjs}

@@ -1,6 +1,6 @@
 import { a as __exportAll } from "./logger-BgksGFuf.mjs";
 import { a as readJson, n as exists, o as readJsonc } from "./fs-CBXKZhoU.mjs";
-import { l as normalizeCascadeConfig, r as DEFAULT_CONFIG } from "./types-Bkh-igOJ.mjs";
+import { l as normalizeCascadeConfig, r as DEFAULT_CONFIG } from "./types-lpiG-Zxh.mjs";
 import { resolve } from "node:path";
 //#region src/core/config.ts
 var config_exports = /* @__PURE__ */ __exportAll({
@@ -89,6 +89,10 @@ function mergeConfig(defaults, user) {
 		packages: {
 			...defaults.packages,
 			...user.packages
+		},
+		channels: {
+			...defaults.channels,
+			...user.channels
 		}
 	};
 }