@varlock/bumpy 1.13.1 → 1.14.0-rc.0

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-5how2kia.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-BbsDr6t7.mjs");
+				const { statusCommand } = await import("./status-CrMvvvNy.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-BUUf8vKC.mjs");
+				await versionCommand(rootDir, {
+					commit: flags.commit === true,
+					channel: flags.channel
+				});
 				break;
 			}
 			case "generate": {
 				const rootDir = await findRoot();
-				const { generateCommand } = await import("./generate-CvCvUaRV.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-CsF0zh8r.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-CIamssoq.mjs");
+					const { ciCheckCommand } = await import("./ci-hO7tAbCN.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-CIamssoq.mjs");
+					const { ciPlanCommand } = await import("./ci-hO7tAbCN.mjs");
 					await ciPlanCommand(rootDir);
 				} else if (subcommand === "release") {
-					const { ciReleaseCommand } = await import("./ci-CIamssoq.mjs");
+					const { ciReleaseCommand } = await import("./ci-hO7tAbCN.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-h6rM58Cq.mjs");
+				const { publishCommand } = await import("./publish-Cz0e4KYT.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;
 			}
@@ -151,7 +157,7 @@ async function main() {
 			}
 			case "--version":
 			case "-v":
-				console.log(`bumpy 1.13.1`);
+				console.log(`bumpy 1.13.2`);
 				break;
 			case "help":
 			case "--help":
@@ -171,7 +177,7 @@ async function main() {
 }
 function printHelp() {
 	console.log(`
-  ${colorize(`🐸 bumpy v1.13.1`, "bold")} - Modern monorepo versioning
+  ${colorize(`🐸 bumpy v1.13.2`, "bold")} - Modern monorepo versioning
 
   Usage: bumpy <command> [options]
 
@@ -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
 		}
 	};
 }

package/dist/{generate-CvCvUaRV.mjs → generate-B2OMt_64.mjs}

@@ -1,9 +1,9 @@
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
 import { t as ensureDir } from "./fs-CBXKZhoU.mjs";
-import { a as loadConfig, r as getBumpyDir } from "./config-D_4GYDJi.mjs";
-import { a as writeBumpFile, o as discoverPackages } from "./bump-file-B7hmXZlB.mjs";
+import { a as loadConfig, r as getBumpyDir } from "./config-0we4ISZX.mjs";
+import { o as writeBumpFile, s as discoverPackages } from "./bump-file-mRJeReRJ.mjs";
 import { s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { r as getBranchCommits, s as getFilesChangedInCommit } from "./git-DJJ64SW9.mjs";
+import { c as getFilesChangedInCommit, i as getBranchCommits } from "./git-DAWj8LyV.mjs";
 import { n as slugify, t as randomName } from "./names-COooXAFg.mjs";
 import { relative } from "node:path";
 //#region src/commands/generate.ts

package/dist/{git-DJJ64SW9.mjs → git-DAWj8LyV.mjs}

@@ -8,13 +8,23 @@ function createTag(tag, opts) {
 		tag
 	], opts);
 }
-/** Push tags to remote, using BUMPY_GH_TOKEN if available */
-function pushWithTags(opts) {
+/**
+* Force-push a single tag to origin, using BUMPY_GH_TOKEN if available.
+*
+* Force is required because `gh release create --draft --target SHA` creates
+* the tag on the remote at draft-creation time. If a previous publish attempt
+* failed and HEAD has since moved, the remote tag points at the stale SHA —
+* `git push --tags` would reject. The caller is responsible for ensuring the
+* local tag is at the correct SHA (i.e. only call after a successful publish).
+*/
+function forcePushTag(tag, opts) {
 	withGitToken(opts?.cwd, () => {
 		runArgs([
 			"git",
 			"push",
-			"--tags"
+			"origin",
+			`refs/tags/${tag}`,
+			"--force"
 		], opts);
 	});
 }
@@ -259,5 +269,16 @@ function getFileStatuses(dir, opts) {
 	}
 	return statuses;
 }
+/** Get all tags matching a pattern */
+function listTags(pattern, opts) {
+	const result = tryRunArgs([
+		"git",
+		"tag",
+		"-l",
+		pattern
+	], opts);
+	if (!result) return [];
+	return result.split("\n").filter(Boolean);
+}
 //#endregion
-export { getCurrentBranch as a, hasUncommittedChanges as c, tagExists as d, withGitToken as f, getChangedFiles as i, pushWithTags as l, getBaseCompareRef as n, getFileStatuses as o, getBranchCommits as r, getFilesChangedInCommit as s, createTag as t, readFileAtRef as u };
+export { getChangedFiles as a, getFilesChangedInCommit as c, readFileAtRef as d, tagExists as f, getBranchCommits as i, hasUncommittedChanges as l, forcePushTag as n, getCurrentBranch as o, withGitToken as p, getBaseCompareRef as r, getFileStatuses as s, createTag as t, listTags as u };

package/dist/index.d.mts

@@ -53,9 +53,30 @@ interface PublishConfig {
    */
   npmStaged: boolean;
 }
+interface ChannelConfig {
+  /** Branch that triggers this channel (required) */
+  branch: string;
+  /** Version suffix (preid), e.g. "rc" → 1.2.0-rc.0. Defaults to the channel name. */
+  preid?: string;
+  /** npm dist-tag for publishes. Defaults to the channel name. */
+  tag?: string;
+  /** Release PR overrides for this channel */
+  versionPr?: {
+    title?: string;
+    branch?: string; /** Enable auto-merge on the release PR */
+    automerge?: boolean;
+  };
+}
 interface BumpyConfig {
   baseBranch: string;
   access: 'public' | 'restricted';
+  /**
+   * Prerelease channels, keyed by channel name. Each maps a long-lived branch
+   * to a prerelease line (version suffix + npm dist-tag). Shipped bump files
+   * are tracked in `.bumpy/<name>/`. Prerelease versions are never committed —
+   * they are derived from bump files, the registry, and git tags at publish time.
+   */
+  channels: Record<string, ChannelConfig>;
   /**
    * Customize the commit message used when versioning.
    * A string starting with "./" is treated as a path to a module that exports
@@ -136,6 +157,8 @@ interface BumpFile {
   id: string;
   releases: BumpFileRelease[];
   summary: string;
+  /** Channel directory this file lives in (`.bumpy/<channel>/`), if any. Undefined = `.bumpy/` root. */
+  channel?: string;
 }
 interface WorkspacePackage {
   name: string;
@@ -219,8 +242,15 @@ interface ReadBumpFilesResult {
   bumpFiles: BumpFile[];
   errors: string[];
 }
-/** Read all bump files from .bumpy/ directory, sorted by git creation order */
-declare function readBumpFiles(rootDir: string): Promise<ReadBumpFilesResult>;
+interface ReadBumpFilesOptions {
+  /**
+   * Channel names whose `.bumpy/<name>/` subdirectories should also be read.
+   * Files from those dirs get their `channel` field set; root files don't.
+   */
+  channels?: string[];
+}
+/** Read all bump files from .bumpy/ (and optionally channel subdirs), sorted by git creation order */
+declare function readBumpFiles(rootDir: string, opts?: ReadBumpFilesOptions): Promise<ReadBumpFilesResult>;
 interface BumpFileParseResult {
   bumpFile: BumpFile | null;
   errors: string[];
@@ -240,7 +270,19 @@ declare function writeBumpFile(rootDir: string, filename: string, releases: Bump
  *   Phase B — enforce fixed/linked group constraints
  *   Phase C — apply cascades and proactive propagation rules
  */
-declare function assembleReleasePlan(bumpFiles: BumpFile[], packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig): ReleasePlan;
+interface AssemblePlanOptions {
+  /**
+   * Prerelease preid for channel plans (e.g. "rc"). When set, Phase A checks range
+   * satisfaction against `<target>-<preid>.0` instead of the stable target. Since a
+   * prerelease never satisfies a normal range (`^1.0.0` doesn't match `1.5.0-rc.0`),
+   * every dependent of a bumped package goes out of range and joins the cycle —
+   * required so consumers can actually install the cycle together from the dist-tag.
+   * Planned versions remain stable targets; the prerelease suffix is applied later
+   * from the registry floor.
+   */
+  prereleasePreid?: string;
+}
+declare function assembleReleasePlan(bumpFiles: BumpFile[], packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig, opts?: AssemblePlanOptions): ReleasePlan;
 //#endregion
 //#region src/core/apply-release-plan.d.ts
 /** Apply the release plan: bump versions, update changelogs, delete bump files */
@@ -322,4 +364,4 @@ interface PublishResult {
  */
 declare function publishPackages(releasePlan: ReleasePlan, packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig, rootDir: string, opts?: PublishOptions, catalogs?: CatalogMap, detectedPm?: PackageManager): Promise<PublishResult>;
 //#endregion
-export { BUMP_LEVELS, BumpFile, type BumpFileParseResult, BumpFileRelease, BumpFileReleaseCascade, BumpFileReleaseSimple, BumpType, BumpTypeWithNone, BumpyConfig, CascadeConfig, CascadeRule, type ChangelogContext, type ChangelogFormatter, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DepType, DependencyBumpRule, DependencyGraph, DependentInfo, type GithubChangelogOptions, PackageConfig, PackageManager, PlannedRelease, PublishConfig, type ReadBumpFilesResult, ReleasePlan, WorkspacePackage, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, normalizeCascadeConfig, parseBumpFile, prependToChangelog, publishPackages, readBumpFiles, satisfies, stripProtocol, writeBumpFile };
+export { BUMP_LEVELS, BumpFile, type BumpFileParseResult, BumpFileRelease, BumpFileReleaseCascade, BumpFileReleaseSimple, BumpType, BumpTypeWithNone, BumpyConfig, CascadeConfig, CascadeRule, type ChangelogContext, type ChangelogFormatter, ChannelConfig, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DepType, DependencyBumpRule, DependencyGraph, DependentInfo, type GithubChangelogOptions, PackageConfig, PackageManager, PlannedRelease, PublishConfig, type ReadBumpFilesResult, ReleasePlan, WorkspacePackage, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, normalizeCascadeConfig, parseBumpFile, prependToChangelog, publishPackages, readBumpFiles, satisfies, stripProtocol, writeBumpFile };

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { a as DEP_TYPES, c as maxBump, i as DEFAULT_PUBLISH_CONFIG, l as normalizeCascadeConfig, n as DEFAULT_BUMP_RULES, o as bumpLevel, r as DEFAULT_CONFIG, s as hasCascade, t as BUMP_LEVELS } from "./types-Bkh-igOJ.mjs";
-import { a as loadConfig, n as findRoot, r as getBumpyDir, s as matchGlob } from "./config-D_4GYDJi.mjs";
-import { a as writeBumpFile, n as parseBumpFile, o as discoverPackages, r as readBumpFiles } from "./bump-file-B7hmXZlB.mjs";
-import { a as DependencyGraph, i as stripProtocol, n as bumpVersion, r as satisfies, t as assembleReleasePlan } from "./release-plan-mK7iGeGq.mjs";
-import { a as prependToChangelog, i as loadFormatter, n as generateChangelogEntry, t as defaultFormatter } from "./changelog-CbaET5V6.mjs";
-import { t as applyReleasePlan } from "./apply-release-plan-DD2R7SL2.mjs";
-import { t as publishPackages } from "./publish-pipeline-DSj14dW6.mjs";
+import { a as DEP_TYPES, c as maxBump, i as DEFAULT_PUBLISH_CONFIG, l as normalizeCascadeConfig, n as DEFAULT_BUMP_RULES, o as bumpLevel, r as DEFAULT_CONFIG, s as hasCascade, t as BUMP_LEVELS } from "./types-lpiG-Zxh.mjs";
+import { a as loadConfig, n as findRoot, r as getBumpyDir, s as matchGlob } from "./config-0we4ISZX.mjs";
+import { i as readBumpFiles, o as writeBumpFile, r as parseBumpFile, s as discoverPackages } from "./bump-file-mRJeReRJ.mjs";
+import { i as stripProtocol, n as bumpVersion, o as DependencyGraph, r as satisfies, t as assembleReleasePlan } from "./release-plan-C84pcBi-.mjs";
+import { a as prependToChangelog, i as loadFormatter, n as generateChangelogEntry, t as defaultFormatter } from "./changelog-DuFhnJRO.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-DxTsUSqa.mjs";
+import { t as publishPackages } from "./publish-pipeline-BD8mLbL9.mjs";
 export { BUMP_LEVELS, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DependencyGraph, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, normalizeCascadeConfig, parseBumpFile, prependToChangelog, publishPackages, readBumpFiles, satisfies, stripProtocol, writeBumpFile };

package/dist/prerelease-Blnk8FE1.mjs

@@ -0,0 +1,186 @@
+import { s as __toESM } from "./logger-BgksGFuf.mjs";
+import { f as writeText, l as updateJsonFields, s as readText, u as updateJsonNestedField } from "./fs-CBXKZhoU.mjs";
+import { a as require_semver } from "./release-plan-C84pcBi-.mjs";
+import { r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
+import { u as listTags } from "./git-DAWj8LyV.mjs";
+import { resolve } from "node:path";
+//#region src/core/prerelease.ts
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+/**
+* Extract existing prerelease counters for a target+preid from a list of published versions.
+* Only exact `<target>-<preid>.<N>` versions count — other preids and targets are ignored.
+*/
+function extractPrereleaseCounters(versions, target, preid) {
+	const counters = [];
+	for (const v of versions) {
+		const parsed = import_semver.default.parse(v);
+		if (!parsed) continue;
+		if (`${parsed.major}.${parsed.minor}.${parsed.patch}` !== target) continue;
+		if (parsed.prerelease.length !== 2) continue;
+		if (parsed.prerelease[0] !== preid) continue;
+		const n = parsed.prerelease[1];
+		if (typeof n === "number") counters.push(n);
+	}
+	return counters;
+}
+/** Compute the next prerelease version: `<target>-<preid>.<max existing counter + 1>` */
+function nextPrereleaseVersion(target, preid, existingCounters) {
+	return `${target}-${preid}.${existingCounters.length > 0 ? Math.max(...existingCounters) + 1 : 0}`;
+}
+/** Fetch all published versions of a package from the registry */
+async function fetchPublishedVersions(name, registry) {
+	const args = [
+		"npm",
+		"info",
+		name,
+		"versions",
+		"--json"
+	];
+	if (registry) args.push("--registry", registry);
+	try {
+		const raw = await runArgsAsync(args);
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string");
+		if (typeof parsed === "string") return [parsed];
+		return [];
+	} catch {
+		return [];
+	}
+}
+/** Fetch the gitHead recorded for a published version (set by npm publish from a git checkout) */
+async function fetchGitHead(name, version, registry) {
+	const args = [
+		"npm",
+		"info",
+		`${name}@${version}`,
+		"gitHead"
+	];
+	if (registry) args.push("--registry", registry);
+	try {
+		const sha = (await runArgsAsync(args)).trim();
+		return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+	} catch {
+		return null;
+	}
+}
+/** Whether a package publishes through the npm registry (vs custom command / git-tag tracking) */
+function usesNpmRegistry(pkg) {
+	return !pkg.bumpy?.publishCommand && !pkg.bumpy?.skipNpmPublish && !pkg.private;
+}
+/** Query published prerelease state for one package at a target version */
+async function getPublishedPrereleaseState(pkg, target, preid, rootDir) {
+	if (usesNpmRegistry(pkg)) {
+		const versions = await fetchPublishedVersions(pkg.name, pkg.bumpy?.registry);
+		return {
+			counters: extractPrereleaseCounters(versions, target, preid),
+			stablePublished: versions.includes(target)
+		};
+	}
+	return {
+		counters: extractPrereleaseCounters(listTags(`${pkg.name}@${target}-${preid}.*`, { cwd: rootDir }).map((t) => t.slice(pkg.name.length + 1)), target, preid),
+		stablePublished: listTags(`${pkg.name}@${target}`, { cwd: rootDir }).length > 0
+	};
+}
+/**
+* Transform a stable release plan (targets computed from bump files) into a channel
+* prerelease plan: each release's newVersion becomes `<target>-<preid>.<N>` with N
+* derived from the registry floor.
+*
+* Idempotency: if a package's latest published prerelease for this target records a
+* gitHead equal to HEAD (or, for non-npm packages, its tag points at HEAD), the package
+* was already published from this exact commit — it is skipped rather than re-counted.
+*/
+async function buildChannelReleasePlan(stablePlan, channel, packages, rootDir, opts = {}) {
+	const headSha = tryRunArgs([
+		"git",
+		"rev-parse",
+		"HEAD"
+	], { cwd: rootDir });
+	const warnings = [...stablePlan.warnings];
+	const alreadyPublished = [];
+	const releases = [];
+	await Promise.all(stablePlan.releases.map(async (release) => {
+		const pkg = packages.get(release.name);
+		if (!pkg) return;
+		if (pkg.private && !pkg.bumpy?.publishCommand) return;
+		const target = release.newVersion;
+		const state = await getPublishedPrereleaseState(pkg, target, channel.preid, rootDir);
+		if (state.stablePublished) warnings.push(`${release.name}@${target} is already published as a stable release — merge ${target}'s release into the "${channel.branch}" branch so the cycle retargets.`);
+		if (!opts.forDisplay && state.counters.length > 0 && headSha) {
+			const latest = `${target}-${channel.preid}.${Math.max(...state.counters)}`;
+			if (usesNpmRegistry(pkg) ? await fetchGitHead(pkg.name, latest, pkg.bumpy?.registry) === headSha : tryRunArgs([
+				"git",
+				"rev-parse",
+				`refs/tags/${pkg.name}@${latest}`
+			], { cwd: rootDir }) === headSha) {
+				alreadyPublished.push({
+					name: release.name,
+					version: latest
+				});
+				return;
+			}
+		}
+		releases.push({
+			...release,
+			newVersion: nextPrereleaseVersion(target, channel.preid, state.counters)
+		});
+	}));
+	releases.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		plan: {
+			bumpFiles: stablePlan.bumpFiles,
+			releases,
+			warnings
+		},
+		alreadyPublished,
+		warnings
+	};
+}
+/**
+* Transiently write computed prerelease versions (and exact pins for in-cycle deps)
+* into the working tree's package.json files. Returns a restore function that puts
+* the original contents back — call it in a `finally` after publishing.
+*
+* Versions must be on disk before build/pack so that:
+* - PM pack picks up the prerelease version for the tarball
+* - builds that bake in the version (banners, __VERSION__) see the right one
+*
+* In-cycle dependencies are pinned EXACTLY (`"1.2.0-rc.0"`, no range) so any
+* combination of packages installed from the channel dist-tag resolves to the
+* coherent set it was published with.
+*/
+async function writeChannelVersionsInPlace(plan, packages) {
+	const releaseMap = new Map(plan.releases.map((r) => [r.name, r]));
+	const originals = /* @__PURE__ */ new Map();
+	for (const release of plan.releases) {
+		const pkg = packages.get(release.name);
+		if (!pkg) continue;
+		const pkgJsonPath = resolve(pkg.dir, "package.json");
+		originals.set(pkgJsonPath, await readText(pkgJsonPath));
+		await updateJsonFields(pkgJsonPath, { version: release.newVersion });
+		for (const depField of [
+			"dependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const deps = pkg[depField];
+			for (const depName of Object.keys(deps)) {
+				const depRelease = releaseMap.get(depName);
+				if (!depRelease) continue;
+				await updateJsonNestedField(pkgJsonPath, depField, depName, depRelease.newVersion);
+			}
+		}
+	}
+	return async () => {
+		for (const [path, content] of originals) await writeText(path, content);
+	};
+}
+/** 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}`;
+}
+//#endregion
+export { formatChannelVersionSummary as n, writeChannelVersionsInPlace as r, buildChannelReleasePlan as t };