@varlock/bumpy 1.14.0-rc.0 → 1.14.0

package/dist/{ci-hO7tAbCN.mjs → ci-BRJNl-VN.mjs}

@@ -8,7 +8,7 @@ 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-DIl9Dz68.mjs";
 import { channelNames, detectReleaseBranch, matchChannelByBranch, resolveChannels } from "./channels-CFXZkyGd.mjs";
-import { n as formatChannelVersionSummary, t as buildChannelReleasePlan } from "./prerelease-Blnk8FE1.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";
@@ -77,9 +77,10 @@ async function ciCheckCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
 	const { packages } = await discoverWorkspace(rootDir, config);
 	const depGraph = new DependencyGraph(packages);
-	const { bumpFiles: allBumpFiles, errors: parseErrors } = await readBumpFiles(rootDir);
+	const { bumpFiles: allBumpFiles, errors: parseErrors } = await readBumpFiles(rootDir, { channels: channelNames(config) });
 	const prBranchName = detectPrBranch(rootDir);
-	const releasePrBranches = new Set([config.versionPr.branch, ...[...resolveChannels(config).values()].map((c) => c.versionPr.branch)]);
+	const channels = resolveChannels(config);
+	const releasePrBranches = new Set([config.versionPr.branch, ...[...channels.values()].map((c) => c.versionPr.branch)]);
 	if (prBranchName && releasePrBranches.has(prBranchName)) {
 		log.dim("  Skipping — this is a release PR branch.");
 		return;
@@ -115,14 +116,14 @@ async function ciCheckCommand(rootDir, opts) {
 		return;
 	}
 	const plan = assembleReleasePlan(prBumpFiles, packages, depGraph, config, prChannel ? { prereleasePreid: prChannel.preid } : {});
-	const releaseSuffix = prChannel ? `-${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}${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, prChannel), rootDir);
+	if (shouldComment && prNumber) await postOrUpdatePrComment(prNumber, formatReleasePlanComment(plan, prBumpFiles, prNumber, detectPrBranch(rootDir), pm, plan.warnings, parseErrors, emptyBumpFileIds, prChannel, channels), 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);
@@ -169,7 +170,7 @@ async function ciPlanCommand(rootDir) {
 		packageNames: plan.releases.map((r) => r.name)
 	};
 	else {
-		const { findUnpublishedPackages } = await import("./publish-Cz0e4KYT.mjs");
+		const { findUnpublishedPackages } = await import("./publish-DWxi552d.mjs");
 		const unpublished = await findUnpublishedPackages(packages, config);
 		if (unpublished.length > 0) output = {
 			mode: "publish",
@@ -253,7 +254,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-Cz0e4KYT.mjs");
+		const { publishCommand } = await import("./publish-DWxi552d.mjs");
 		await publishCommand(rootDir, {
 			tag: opts.tag,
 			recoveredBumpFiles
@@ -277,7 +278,7 @@ async function ciReleaseCommand(rootDir, opts) {
 */
 async function autoPublish(rootDir, config, plan, tag) {
 	log.step("Running bumpy version...");
-	const { versionCommand } = await import("./version-BUUf8vKC.mjs");
+	const { versionCommand } = await import("./version-CMJUopVj.mjs");
 	await versionCommand(rootDir);
 	log.step("Committing version changes...");
 	runArgs([
@@ -306,7 +307,7 @@ async function autoPublish(rootDir, config, plan, tag) {
 		], { cwd: rootDir });
 	}
 	log.step("Running bumpy publish...");
-	const { publishCommand } = await import("./publish-Cz0e4KYT.mjs");
+	const { publishCommand } = await import("./publish-DWxi552d.mjs");
 	await publishCommand(rootDir, { tag });
 }
 /**
@@ -380,7 +381,7 @@ async function createVersionPr(rootDir, plan, config, packageDirs, branchName) {
 		branch
 	], { cwd: rootDir });
 	log.step("Running bumpy version...");
-	const { versionCommand } = await import("./version-BUUf8vKC.mjs");
+	const { versionCommand } = await import("./version-CMJUopVj.mjs");
 	await versionCommand(rootDir);
 	runArgs([
 		"git",
@@ -475,6 +476,93 @@ async function createVersionPr(rootDir, plan, config, packageDirs, branchName) {
 		"checkout",
 		baseBranch
 	], { cwd: rootDir });
+	await closePromotedChannelReleasePrs(rootDir, config, plan.bumpFiles);
+}
+/**
+* Channels whose dirs gained bump files in the triggering push — i.e. this push is
+* the promotion/graduation merge that delivered them. (Same range detection as the
+* channel publish trigger.)
+*/
+function detectArrivedChannelFiles(rootDir, config) {
+	const range = getPushEventRange();
+	let diffRange;
+	if (range) diffRange = `${range.before}..${range.after}`;
+	else {
+		if (!tryRunArgs([
+			"git",
+			"rev-parse",
+			"--verify",
+			"HEAD^"
+		], { cwd: rootDir })) return /* @__PURE__ */ new Set();
+		diffRange = "HEAD^..HEAD";
+	}
+	const out = tryRunArgs([
+		"git",
+		"diff",
+		"--name-only",
+		"--diff-filter=A",
+		"--no-renames",
+		diffRange,
+		"--",
+		".bumpy/"
+	], { cwd: rootDir });
+	if (!out) return /* @__PURE__ */ new Set();
+	const knownChannels = new Set(channelNames(config));
+	const arrived = /* @__PURE__ */ new Set();
+	for (const f of out.split("\n")) {
+		if (!f.endsWith(".md") || f.endsWith("README.md")) continue;
+		const parts = f.split("/");
+		if (parts.length === 3 && knownChannels.has(parts[1])) arrived.add(parts[1]);
+	}
+	return arrived;
+}
+/**
+* Close lingering channel release PRs whose cycles were promoted: once a channel's
+* bump files are pending on this branch (via a promotion or graduation merge), the
+* source channel's own release PR is obsolete — merging it would re-publish a cycle
+* that's already moving to its next stage. A fresh release PR is created automatically
+* if new work lands on the channel branch.
+*
+* Only channels whose files arrived in the TRIGGERING push are considered: the files
+* stay pending here until our version/release PR merges, and re-closing on every
+* later push in that window would kill the release PR of a newly restarted cycle.
+*/
+async function closePromotedChannelReleasePrs(rootDir, config, bumpFiles, currentChannel) {
+	const arrived = detectArrivedChannelFiles(rootDir, config);
+	const promoted = [...new Set(bumpFiles.map((bf) => bf.channel))].filter((name) => name != null && name !== currentChannel?.name && arrived.has(name));
+	if (promoted.length === 0) return;
+	const channels = resolveChannels(config);
+	for (const name of promoted) {
+		const channel = channels.get(name);
+		if (!channel) continue;
+		const pr = tryRunArgs([
+			"gh",
+			"pr",
+			"list",
+			"--head",
+			channel.versionPr.branch,
+			"--json",
+			"number",
+			"--jq",
+			".[0].number"
+		], { cwd: rootDir });
+		if (!pr) continue;
+		const validPr = validatePrNumber(pr);
+		log.step(`Closing release PR #${validPr} — the "${name}" cycle's changes are pending here now...`);
+		try {
+			await withPatToken(() => runArgsAsync([
+				"gh",
+				"pr",
+				"close",
+				validPr,
+				"--comment",
+				`Closing — the \`${name}\` cycle's bump files were promoted and are now pending a release here. A new release PR will be created automatically if more changes land on \`${channel.branch}\`.`
+			], { cwd: rootDir }));
+			log.success(`🐸 Closed obsolete release PR #${validPr}`);
+		} catch (e) {
+			log.warn(`  Failed to close release PR #${validPr}: ${e}`);
+		}
+	}
 }
 /** Read the push event's before/after range, if running on a GitHub Actions push event */
 function getPushEventRange() {
@@ -548,14 +636,14 @@ async function ciChannelRelease(rootDir, config, channel, opts) {
 	const pending = bumpFiles.filter((bf) => bf.channel !== channel.name);
 	if (opts.autoPublish) {
 		if (pending.length > 0) {
-			const { channelVersion } = await import("./version-BUUf8vKC.mjs");
+			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-Cz0e4KYT.mjs");
+		const { publishCommand } = await import("./publish-DWxi552d.mjs");
 		await publishCommand(rootDir, {
 			channel: channel.name,
 			tag: opts.tag
@@ -566,7 +654,7 @@ async function ciChannelRelease(rootDir, config, channel, opts) {
 	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-Cz0e4KYT.mjs");
+		const { publishCommand } = await import("./publish-DWxi552d.mjs");
 		await publishCommand(rootDir, {
 			channel: channel.name,
 			tag: opts.tag
@@ -582,8 +670,8 @@ async function ciChannelRelease(rootDir, config, channel, opts) {
 /**
 * 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. Computed prerelease versions appear in the PR title and body as
-* point-in-time narrative; the registry wins at publish time.
+* 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);
@@ -623,7 +711,7 @@ async function createChannelReleasePr(rootDir, config, channel, packages, branch
 		"-b",
 		branch
 	], { cwd: rootDir });
-	const { channelVersion } = await import("./version-BUUf8vKC.mjs");
+	const { channelVersion } = await import("./version-CMJUopVj.mjs");
 	const result = await channelVersion(rootDir, config, channel);
 	if (!result) {
 		log.info("No pending bump files to move.");
@@ -634,22 +722,7 @@ async function createChannelReleasePr(rootDir, config, channel, packages, branch
 		], { cwd: rootDir });
 		return;
 	}
-	let displayPlan = result.cyclePlan;
-	let displayIsExact = false;
-	try {
-		const built = await buildChannelReleasePlan(result.cyclePlan, channel, packages, rootDir, { forDisplay: true });
-		if (built.plan.releases.length > 0) {
-			displayPlan = built.plan;
-			displayIsExact = true;
-		}
-	} catch {}
-	if (!displayIsExact) displayPlan = {
-		...displayPlan,
-		releases: displayPlan.releases.map((r) => ({
-			...r,
-			newVersion: `${r.newVersion}-${channel.preid}.?`
-		}))
-	};
+	const displayPlan = channelDisplayPlan(result.cyclePlan, channel, packages);
 	const versionSummary = formatChannelVersionSummary(displayPlan.releases);
 	const prTitle = versionSummary ? `${channel.versionPr.title}: ${versionSummary}` : channel.versionPr.title;
 	runArgs([
@@ -747,13 +820,14 @@ async function createChannelReleasePr(rootDir, config, channel, packages, branch
 		"checkout",
 		baseBranch
 	], { cwd: rootDir });
+	await closePromotedChannelReleasePrs(rootDir, config, result.movedFiles, channel);
 }
 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. Version numbers shown here are estimates; the registry wins at publish.`
+		`> 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 */
@@ -839,11 +913,13 @@ function pmRunCommand(pm) {
 	if (pm === "yarn") return "yarn bumpy";
 	return "npx bumpy";
 }
-function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warnings = [], parseErrors = [], emptyBumpFileIds = [], channel = null) {
+function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warnings = [], parseErrors = [], emptyBumpFileIds = [], channel = null, allChannels = null) {
 	const repo = process.env.GITHUB_REPOSITORY;
 	const lines = [];
-	const versionSuffix = channel ? `-${channel.preid}.?` : "";
-	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 versionSuffix = channel ? `-${channel.preid}.x` : "";
+	const promotedChannels = channel ? [] : [...new Set(bumpFiles.map((bf) => bf.channel))].filter((c) => c != null);
+	const channelTag = (name) => `\`@${allChannels?.get(name)?.tag ?? name}\``;
+	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.` : promotedChannels.length > 0 ? `**This PR promotes the ${promotedChannels.map((c) => `\`${c}\``).join(", ")} prerelease cycle${promotedChannels.length > 1 ? "s" : ""} to a stable release.** The changes below that already shipped to the ${promotedChannels.map(channelTag).join(", ")} dist-tag${promotedChannels.length > 1 ? "s" : ""} will be consolidated into the next stable version bump.` : "**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>`,
 		"",
@@ -876,14 +952,15 @@ function formatReleasePlanComment(plan, bumpFiles, prNumber, prBranch, pm, warni
 	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 \`.?\` counter is filled in from the registry. Promote to a stable release by merging \`${channel.branch}\` into your base branch.`);
+		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) {
-		const filename = `${bf.id}.md`;
+		const filename = bf.channel ? `${bf.channel}/${bf.id}.md` : `${bf.id}.md`;
 		const parts = [`\`${filename}\``];
+		if (bf.channel) parts.push(`_(shipped on ${channelTag(bf.channel)})_`);
 		if (repo) {
 			parts.push(`([view diff](https://github.com/${repo}/pull/${prNumber}/changes#diff-${sha256Hex(`.bumpy/${filename}`)}))`);
 			if (prBranch) parts.push(`([edit](https://github.com/${repo}/edit/${prBranch}/.bumpy/${filename}))`);

package/dist/cli.mjs

@@ -43,7 +43,7 @@ async function main() {
 			}
 			case "status": {
 				const rootDir = await findRoot();
-				const { statusCommand } = await import("./status-CrMvvvNy.mjs");
+				const { statusCommand } = await import("./status-DIzi-Iai.mjs");
 				await statusCommand(rootDir, {
 					json: flags.json === true,
 					packagesOnly: flags.packages === true,
@@ -56,7 +56,7 @@ async function main() {
 			}
 			case "version": {
 				const rootDir = await findRoot();
-				const { versionCommand } = await import("./version-BUUf8vKC.mjs");
+				const { versionCommand } = await import("./version-CMJUopVj.mjs");
 				await versionCommand(rootDir, {
 					commit: flags.commit === true,
 					channel: flags.channel
@@ -94,17 +94,17 @@ async function main() {
 				const subcommand = args[1];
 				const ciFlags = parseFlags(args.slice(2));
 				if (subcommand === "check") {
-					const { ciCheckCommand } = await import("./ci-hO7tAbCN.mjs");
+					const { ciCheckCommand } = await import("./ci-BRJNl-VN.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-hO7tAbCN.mjs");
+					const { ciPlanCommand } = await import("./ci-BRJNl-VN.mjs");
 					await ciPlanCommand(rootDir);
 				} else if (subcommand === "release") {
-					const { ciReleaseCommand } = await import("./ci-hO7tAbCN.mjs");
+					const { ciReleaseCommand } = await import("./ci-BRJNl-VN.mjs");
 					const expectModeFlag = ciFlags["expect-mode"];
 					const autoPublishFlag = ciFlags["auto-publish"] === true;
 					if (expectModeFlag !== void 0 && expectModeFlag !== "version-pr" && expectModeFlag !== "publish") {
@@ -132,7 +132,7 @@ async function main() {
 			}
 			case "publish": {
 				const rootDir = await findRoot();
-				const { publishCommand } = await import("./publish-Cz0e4KYT.mjs");
+				const { publishCommand } = await import("./publish-DWxi552d.mjs");
 				await publishCommand(rootDir, {
 					dryRun: flags["dry-run"] === true,
 					tag: flags.tag,
@@ -157,7 +157,7 @@ async function main() {
 			}
 			case "--version":
 			case "-v":
-				console.log(`bumpy 1.13.2`);
+				console.log(`bumpy 1.14.0`);
 				break;
 			case "help":
 			case "--help":
@@ -177,7 +177,7 @@ async function main() {
 }
 function printHelp() {
 	console.log(`
-  ${colorize(`🐸 bumpy v1.13.2`, "bold")} - Modern monorepo versioning
+  ${colorize(`🐸 bumpy v1.14.0`, "bold")} - Modern monorepo versioning
 
   Usage: bumpy <command> [options]
 

package/dist/{prerelease-Blnk8FE1.mjs → prerelease-B2PVfXkm.mjs}

@@ -175,12 +175,31 @@ async function writeChannelVersionsInPlace(plan, packages) {
 		for (const [path, content] of originals) await writeText(path, content);
 	};
 }
+/**
+* Derive display versions for a channel cycle without touching the registry:
+* each target gets a wildcard counter (`1.2.0-rc.x`). Everything here comes from
+* committed state (bump files + config), so PR titles/bodies and commit messages
+* can never disagree with what eventually publishes. Unpublishable packages are
+* dropped, mirroring the filter in `buildChannelReleasePlan`.
+*/
+function channelDisplayPlan(stablePlan, channel, packages) {
+	const releases = stablePlan.releases.filter((r) => {
+		const pkg = packages.get(r.name);
+		return !!pkg && !(pkg.private && !pkg.bumpy?.publishCommand);
+	}).map((r) => ({
+		...r,
+		newVersion: `${r.newVersion}-${channel.preid}.x`
+	}));
+	return {
+		...stablePlan,
+		releases
+	};
+}
 /** One-line summary of a channel plan's versions, for PR titles and commit messages */
 function formatChannelVersionSummary(releases) {
 	if (releases.length === 0) return "";
-	const lead = releases.filter((r) => !r.isDependencyBump && !r.isCascadeBump && !r.isGroupBump)[0] ?? releases[0];
-	const rest = releases.length - 1;
-	return rest > 0 ? `${lead.name}@${lead.newVersion} (+${rest} more)` : `${lead.name}@${lead.newVersion}`;
+	if (releases.length === 1) return `${releases[0].name}@${releases[0].newVersion}`;
+	return `${releases.length} packages`;
 }
 //#endregion
-export { formatChannelVersionSummary as n, writeChannelVersionsInPlace as r, buildChannelReleasePlan as t };
+export { writeChannelVersionsInPlace as i, channelDisplayPlan as n, formatChannelVersionSummary as r, buildChannelReleasePlan as t };

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

@@ -8,8 +8,8 @@ import { i as loadFormatter, n as generateChangelogEntry } from "./changelog-DuF
 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";
+import { i as writeChannelVersionsInPlace, t as buildChannelReleasePlan } from "./prerelease-B2PVfXkm.mjs";
+import { CI_PLAN_CACHE_PATH } from "./ci-BRJNl-VN.mjs";
 //#region src/core/github-release.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
 /** Get the current HEAD commit SHA */

package/dist/{status-CrMvvvNy.mjs → status-DIzi-Iai.mjs}

@@ -4,7 +4,7 @@ import { i as readBumpFiles, s as discoverPackages, t as filterBranchBumpFiles }
 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";
+import { t as buildChannelReleasePlan } from "./prerelease-B2PVfXkm.mjs";
 //#region src/commands/status.ts
 async function statusCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);

package/dist/{version-BUUf8vKC.mjs → version-CMJUopVj.mjs}

@@ -125,7 +125,7 @@ async function channelVersion(rootDir, config, channel, opts = {}) {
 	log.step("Cycle targets (counters are derived from the registry at publish time):");
 	for (const r of cyclePlan.releases) {
 		const tag = r.isDependencyBump ? " (dep)" : r.isCascadeBump ? " (cascade)" : "";
-		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(`${r.newVersion}-${channel.preid}.?`, "cyan")}${tag}`);
+		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(`${r.newVersion}-${channel.preid}.x`, "cyan")}${tag}`);
 	}
 	await moveBumpFilesToChannel(rootDir, pending, channel.name);
 	log.success(`🐸 Moved ${pending.length} bump file(s) — no versions written (prereleases are derived, not committed)`);

package/package.json

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