@varlock/bumpy 1.9.2 → 1.10.0

package/dist/publish-B3D-70sJ.mjs

@@ -0,0 +1,622 @@
+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 detectWorkspaces } from "./package-manager-BQPwXwu5.mjs";
+import { s as discoverWorkspace } from "./bump-file-B9DpXK5X.mjs";
+import { a as DependencyGraph } from "./release-plan-mK7iGeGq.mjs";
+import { r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
+import { i as loadFormatter, n as generateChangelogEntry } from "./changelog-A-EwWggW.mjs";
+import { c as pushWithTags, s as hasUncommittedChanges } from "./git-JGLQtk-M.mjs";
+import { t as publishPackages } from "./publish-pipeline-BRnqVylg.mjs";
+import { CI_PLAN_CACHE_PATH } from "./ci-DeZ4zHmn.mjs";
+//#region src/core/github-release.ts
+/** Get the current HEAD commit SHA */
+function getHeadSha(rootDir) {
+	return tryRunArgs([
+		"git",
+		"rev-parse",
+		"HEAD"
+	], { cwd: rootDir });
+}
+/**
+* Run an async function with BUMPY_GH_TOKEN as GH_TOKEN if available.
+*
+* GitHub releases created with the default GITHUB_TOKEN won't trigger
+* downstream workflows.  Using BUMPY_GH_TOKEN (a PAT or App token)
+* allows `release` events to fire follow-up workflows.
+*
+* Any errors are scrubbed so the token never appears in CI logs.
+*/
+async function withReleaseToken(fn) {
+	const token = process.env.BUMPY_GH_TOKEN;
+	if (!token) return fn();
+	const original = process.env.GH_TOKEN;
+	process.env.GH_TOKEN = token;
+	try {
+		return await fn();
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(msg.replaceAll(token, "***"));
+	} finally {
+		if (original !== void 0) process.env.GH_TOKEN = original;
+		else delete process.env.GH_TOKEN;
+	}
+}
+/** Create individual GitHub releases for each published package */
+async function createIndividualReleases(releases, bumpFiles, rootDir, opts = {}) {
+	if (!isGhAvailable()) {
+		log.dim("  gh CLI not found — skipping GitHub releases");
+		return;
+	}
+	const headSha = getHeadSha(rootDir);
+	for (const release of releases) {
+		const tag = `${release.name}@${release.newVersion}`;
+		const body = opts.formatter ? await generateReleaseBody(release, bumpFiles, opts.formatter) : buildReleaseBody(release, bumpFiles);
+		const title = `${release.name} v${release.newVersion}`;
+		if (opts.dryRun) {
+			log.dim(`  Would create GitHub release: ${title}`);
+			continue;
+		}
+		try {
+			const args = [
+				"gh",
+				"release",
+				"create",
+				tag,
+				"--title",
+				title,
+				"--notes",
+				body
+			];
+			if (headSha) args.push("--target", headSha);
+			await withReleaseToken(() => runArgsAsync(args, { cwd: rootDir }));
+			log.dim(`  Created GitHub release: ${title}`);
+		} catch (err) {
+			log.warn(`  Failed to create GitHub release for ${tag}: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+}
+/** Generate a release body for a single package using the changelog formatter */
+async function generateReleaseBody(release, bumpFiles, formatter) {
+	return stripVersionHeading(await generateChangelogEntry(release, bumpFiles, formatter, void 0, "github-release")).trim() || "No changelog entries.";
+}
+/** Strip the leading ## version heading and date sub-heading from a changelog entry */
+function stripVersionHeading(entry) {
+	return entry.replace(/^## .+\n/, "").replace(/^<sub>.+<\/sub>\n/, "").replace(/^_.+_\n/, "");
+}
+function buildReleaseBody(release, bumpFiles) {
+	const lines = [];
+	const relevant = bumpFiles.filter((bf) => release.bumpFiles.includes(bf.id));
+	if (relevant.length > 0) {
+		for (const bf of relevant) if (bf.summary) lines.push(`- ${bf.summary.split("\n")[0]}`);
+	}
+	if (relevant.length === 0) {
+		const sourceList = release.bumpSources.map((s) => `\`${s.name}\` v${s.newVersion}`).join(", ");
+		if (release.isDependencyBump) lines.push(sourceList ? `- Updated dependency ${sourceList}` : "- Updated dependencies");
+		else if (release.isGroupBump) lines.push(sourceList ? `- Version bump from group with ${sourceList}` : "- Version bump from group");
+		else if (release.isCascadeBump) lines.push(sourceList ? `- Version bump from ${sourceList}` : "- Version bump via cascade rule");
+	}
+	return lines.join("\n") || "No changelog entries.";
+}
+function isGhAvailable() {
+	return tryRunArgs(["gh", "--version"]) !== null;
+}
+const METADATA_START = "<!-- bumpy-metadata";
+const METADATA_END = "bumpy-metadata -->";
+/** Parse bumpy metadata from a release body */
+function parseReleaseMetadata(body) {
+	const startIdx = body.indexOf(METADATA_START);
+	const endIdx = body.indexOf(METADATA_END);
+	if (startIdx === -1 || endIdx === -1) return null;
+	const jsonStr = body.slice(startIdx + 19, endIdx).trim();
+	try {
+		return JSON.parse(jsonStr);
+	} catch {
+		return null;
+	}
+}
+/** Serialize metadata into an HTML comment */
+function serializeMetadata(metadata) {
+	return `${METADATA_START}\n${JSON.stringify(metadata, null, 2)}\n${METADATA_END}`;
+}
+/** Build the "Published to" section from target states */
+function formatPublishedToSection(targets) {
+	const lines = ["#### Published to"];
+	for (const [name, state] of Object.entries(targets)) switch (state.status) {
+		case "success":
+			lines.push(state.url ? `- ✅ [${name}](${state.url})` : `- ✅ ${name}`);
+			break;
+		case "failed":
+			lines.push(`- ❌ ${name} — will retry on next CI run`);
+			break;
+		case "skipped":
+			lines.push(state.supersededBy ? `- ⏭️ ${name} — skipped (superseded by ${state.supersededBy})` : `- ⏭️ ${name} — skipped`);
+			break;
+		case "pending":
+			lines.push(`- ⏳ ${name}`);
+			break;
+	}
+	return lines.join("\n");
+}
+/** Build a URL for a published package on a registry */
+function buildPublishUrl(name, version, targetType, _registry) {
+	switch (targetType) {
+		case "npm": return `https://www.npmjs.com/package/${name}/v/${version}`;
+		case "jsr": {
+			const parts = name.startsWith("@") ? name.slice(1).split("/") : [name];
+			return parts.length === 2 ? `https://jsr.io/@${parts[0]}/${parts[1]}@${version}` : `https://jsr.io/${name}@${version}`;
+		}
+		default: return;
+	}
+}
+/**
+* Compose a full release body from changelog content + publish status + metadata.
+* Preserves existing changelog content when updating (only replaces the status/metadata sections).
+*/
+function composeReleaseBody(changelogContent, metadata) {
+	return `${changelogContent}\n\n${formatPublishedToSection(metadata.targets)}\n\n${serializeMetadata(metadata)}`;
+}
+/**
+* Update just the status/metadata sections of an existing release body,
+* preserving the changelog content above.
+*/
+function updateReleaseBodyStatus(existingBody, metadata) {
+	const publishIdx = existingBody.indexOf("#### Published to");
+	const metaIdx = existingBody.indexOf(METADATA_START);
+	let changelogContent;
+	if (publishIdx !== -1) changelogContent = existingBody.slice(0, publishIdx).trimEnd();
+	else if (metaIdx !== -1) changelogContent = existingBody.slice(0, metaIdx).trimEnd();
+	else changelogContent = existingBody.trimEnd();
+	return composeReleaseBody(changelogContent, metadata);
+}
+/** Look up an existing GitHub release (draft or published) by tag */
+async function findReleaseByTag(tag, rootDir) {
+	if (!isGhAvailable()) return null;
+	try {
+		const json = await runArgsAsync([
+			"gh",
+			"release",
+			"view",
+			tag,
+			"--json",
+			"tagName,name,body,isDraft"
+		], { cwd: rootDir });
+		const data = JSON.parse(json);
+		return {
+			tag: data.tagName,
+			title: data.name,
+			body: data.body,
+			isDraft: data.isDraft,
+			metadata: parseReleaseMetadata(data.body)
+		};
+	} catch {
+		return null;
+	}
+}
+/** Create a draft GitHub release */
+async function createDraftRelease(tag, title, body, rootDir, targetSha) {
+	const args = [
+		"gh",
+		"release",
+		"create",
+		tag,
+		"--title",
+		title,
+		"--notes",
+		body,
+		"--draft"
+	];
+	if (targetSha) args.push("--target", targetSha);
+	await runArgsAsync(args, { cwd: rootDir });
+}
+/** Update an existing GitHub release's body */
+async function updateReleaseBody(tag, body, rootDir) {
+	await runArgsAsync([
+		"gh",
+		"release",
+		"edit",
+		tag,
+		"--notes",
+		body
+	], { cwd: rootDir });
+}
+/** Finalize a draft release (remove draft status) */
+async function finalizeRelease(tag, rootDir) {
+	await runArgsAsync([
+		"gh",
+		"release",
+		"edit",
+		tag,
+		"--draft=false"
+	], { cwd: rootDir });
+}
+/** Find draft releases for a package (by name prefix) that are older than the current version */
+async function findStaleDraftReleases(packageName, currentVersion, rootDir) {
+	if (!isGhAvailable()) return [];
+	const currentTag = `${packageName}@${currentVersion}`;
+	try {
+		const json = await runArgsAsync([
+			"gh",
+			"release",
+			"list",
+			"--json",
+			"tagName,isDraft,name",
+			"--limit",
+			"20"
+		], { cwd: rootDir });
+		const releases = JSON.parse(json);
+		const stale = [];
+		for (const r of releases) {
+			if (!r.isDraft) continue;
+			if (!r.tagName.startsWith(`${packageName}@`)) continue;
+			if (r.tagName === currentTag) continue;
+			const info = await findReleaseByTag(r.tagName, rootDir);
+			if (info) stale.push({
+				tag: r.tagName,
+				body: info.body,
+				metadata: info.metadata
+			});
+		}
+		return stale;
+	} catch {
+		return [];
+	}
+}
+/**
+* Finalize stale draft releases as superseded.
+* Updates their metadata targets to "skipped" and marks them as non-draft.
+*/
+async function finalizeSupersededDrafts(packageName, newVersion, rootDir) {
+	const staleDrafts = await findStaleDraftReleases(packageName, newVersion, rootDir);
+	for (const draft of staleDrafts) {
+		log.dim(`  Finalizing draft release ${draft.tag} — superseded by ${newVersion}`);
+		if (draft.metadata) {
+			for (const [targetName, state] of Object.entries(draft.metadata.targets)) if (state.status !== "success") draft.metadata.targets[targetName] = {
+				status: "skipped",
+				reason: "superseded",
+				supersededBy: newVersion
+			};
+			const updatedBody = updateReleaseBodyStatus(draft.body, draft.metadata);
+			try {
+				await updateReleaseBody(draft.tag, updatedBody, rootDir);
+				await finalizeRelease(draft.tag, rootDir);
+			} catch (err) {
+				log.warn(`  Failed to finalize superseded release ${draft.tag}: ${err instanceof Error ? err.message : err}`);
+			}
+		} else try {
+			await finalizeRelease(draft.tag, rootDir);
+		} catch (err) {
+			log.warn(`  Failed to finalize superseded release ${draft.tag}: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+}
+//#endregion
+//#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.
+*/
+async function publishCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const { packages, catalogs } = await discoverWorkspace(rootDir, config);
+	const { packageManager: detectedPm } = await detectWorkspaces(rootDir);
+	const depGraph = new DependencyGraph(packages);
+	if (!opts.dryRun && hasUncommittedChanges({ cwd: rootDir })) {
+		log.warn("You have uncommitted changes. Commit or stash them before publishing.");
+		process.exit(1);
+	}
+	let toPublish = await findUnpublishedWithCache(rootDir, packages, config);
+	if (opts.excludePackages && opts.excludePackages.size > 0) {
+		const excluded = toPublish.filter((r) => opts.excludePackages.has(r.name));
+		if (excluded.length > 0) {
+			for (const r of excluded) log.dim(`  Skipping ${r.name}@${r.newVersion} — pending bump will supersede this version`);
+			toPublish = toPublish.filter((r) => !opts.excludePackages.has(r.name));
+		}
+	}
+	if (opts.filter) {
+		const { matchGlob } = await import("./config-D_4GYDJi.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 unpublished packages found.");
+		return;
+	}
+	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 = {
+		bumpFiles: recoveredBumpFiles,
+		releases: toPublish,
+		warnings: []
+	};
+	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();
+	const formatter = config.changelog !== false ? await loadFormatter(config.changelog, rootDir) : void 0;
+	const ghAvailable = isGhAvailable();
+	const publishTargetsByPkg = /* @__PURE__ */ new Map();
+	for (const release of toPublish) {
+		const pkgConfig = packages.get(release.name).bumpy || {};
+		const targets = [];
+		if (pkgConfig.publishCommand) targets.push("custom");
+		else if (!pkgConfig.skipNpmPublish) targets.push("npm");
+		publishTargetsByPkg.set(release.name, targets);
+	}
+	const releaseMetadataByPkg = /* @__PURE__ */ new Map();
+	if (ghAvailable && !opts.dryRun) {
+		for (const release of toPublish) {
+			const tag = `${release.name}@${release.newVersion}`;
+			const targets = publishTargetsByPkg.get(release.name) || [];
+			if (targets.length === 0) continue;
+			const existing = await findReleaseByTag(tag, rootDir);
+			if (existing && existing.metadata) {
+				log.dim(`  Found existing release for ${tag} (${existing.isDraft ? "draft" : "published"})`);
+				releaseMetadataByPkg.set(release.name, {
+					tag,
+					metadata: existing.metadata,
+					existingBody: existing.body
+				});
+			} else if (existing && !existing.metadata) log.dim(`  Found existing release for ${tag} without bumpy metadata — skipping draft management`);
+			else {
+				await finalizeSupersededDrafts(release.name, release.newVersion, rootDir);
+				const changelogContent = formatter ? await generateReleaseBody(release, releasePlan.bumpFiles, formatter) : buildReleaseBody(release, releasePlan.bumpFiles);
+				const initialTargets = {};
+				for (const t of targets) initialTargets[t] = { status: "pending" };
+				const metadata = {
+					version: release.newVersion,
+					targets: initialTargets
+				};
+				const body = composeReleaseBody(changelogContent, metadata);
+				const title = `${release.name} v${release.newVersion}`;
+				const headSha = getHeadSha(rootDir);
+				try {
+					await createDraftRelease(tag, title, body, rootDir, headSha || void 0);
+					log.dim(`  Created draft release: ${title}`);
+					releaseMetadataByPkg.set(release.name, {
+						tag,
+						metadata,
+						existingBody: body
+					});
+				} catch (err) {
+					log.warn(`  Failed to create draft release for ${tag}: ${err instanceof Error ? err.message : err}`);
+				}
+			}
+		}
+		for (const release of toPublish) {
+			const info = releaseMetadataByPkg.get(release.name);
+			if (!info) continue;
+			if (!Object.values(info.metadata.targets).some((t) => t.status === "success")) {
+				const tag = info.tag;
+				const headSha = getHeadSha(rootDir);
+				const tagSha = tryRunArgs([
+					"git",
+					"rev-parse",
+					tag
+				], { cwd: rootDir });
+				if (headSha && tagSha && headSha !== tagSha) {
+					const count = tryRunArgs([
+						"git",
+						"rev-list",
+						"--count",
+						`${tag}..HEAD`
+					], { cwd: rootDir });
+					log.dim(`  Moving version tag ${tag} to HEAD (includes ${count} commit(s) since versioning)`);
+					tryRunArgs([
+						"git",
+						"tag",
+						"-f",
+						tag
+					], { cwd: rootDir });
+				}
+			} else {
+				const tag = info.tag;
+				const headSha = getHeadSha(rootDir);
+				const tagSha = tryRunArgs([
+					"git",
+					"rev-parse",
+					tag
+				], { cwd: rootDir });
+				if (headSha && tagSha && headSha !== tagSha) {
+					const count = tryRunArgs([
+						"git",
+						"rev-list",
+						"--count",
+						`${tag}..HEAD`
+					], { cwd: rootDir });
+					log.warn(`  HEAD is ${count} commit(s) ahead of version tag ${tag} — some targets already published from tagged commit`);
+				}
+			}
+		}
+	}
+	const alreadyPublished = [];
+	for (const release of toPublish) {
+		const info = releaseMetadataByPkg.get(release.name);
+		if (!info) continue;
+		if ((publishTargetsByPkg.get(release.name) || []).every((t) => info.metadata.targets[t]?.status === "success")) alreadyPublished.push(release.name);
+	}
+	if (alreadyPublished.length > 0) {
+		for (const name of alreadyPublished) log.dim(`  Skipping ${name} — all targets already published (per draft release metadata)`);
+		toPublish = toPublish.filter((r) => !alreadyPublished.includes(r.name));
+		releasePlan.releases = toPublish;
+	}
+	if (toPublish.length === 0) {
+		log.info("All packages already published successfully.");
+		return;
+	}
+	const result = await publishPackages(releasePlan, packages, depGraph, config, rootDir, {
+		dryRun: opts.dryRun,
+		tag: opts.tag
+	}, catalogs, detectedPm);
+	if (result.published.length > 0) log.success(`🐸 Published ${result.published.length} package(s)`);
+	if (result.skipped.length > 0) log.dim(`Skipped ${result.skipped.length}: ${result.skipped.map((s) => s.name).join(", ")}`);
+	if (ghAvailable && !opts.dryRun) for (const release of releasePlan.releases) {
+		const info = releaseMetadataByPkg.get(release.name);
+		if (!info) continue;
+		const targets = publishTargetsByPkg.get(release.name) || [];
+		const published = result.published.find((p) => p.name === release.name);
+		const failed = result.failed.find((f) => f.name === release.name);
+		let changed = false;
+		for (const targetName of targets) {
+			if (info.metadata.targets[targetName]?.status === "success") continue;
+			if (published) {
+				info.metadata.targets[targetName] = {
+					status: "success",
+					publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					url: buildPublishUrl(release.name, release.newVersion, targetName)
+				};
+				changed = true;
+			} else if (failed) {
+				info.metadata.targets[targetName] = {
+					status: "failed",
+					error: failed.error,
+					lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				changed = true;
+			}
+		}
+		if (changed) try {
+			const updatedBody = info.existingBody ? updateReleaseBodyStatus(info.existingBody, info.metadata) : composeReleaseBody("", info.metadata);
+			await updateReleaseBody(info.tag, updatedBody, rootDir);
+			if (Object.values(info.metadata.targets).every((t) => t.status === "success")) {
+				await finalizeRelease(info.tag, rootDir);
+				log.dim(`  Finalized release: ${info.tag}`);
+			}
+		} catch (err) {
+			log.warn(`  Failed to update release for ${info.tag}: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+	if (result.failed.length > 0) {
+		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 {
+		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}`);
+	}
+	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,
+		formatter
+	});
+}
+/**
+* Try to load cached plan from `ci plan`. Returns the unpublished package names
+* if the cache is valid, or null to fall back to registry lookups.
+*
+* Validates that every cached package exists in the workspace with the same version,
+* so the cache can only filter — never fabricate — the set of packages.
+*/
+function loadCachedPlan(rootDir, packages) {
+	const cachePath = `${rootDir}/${CI_PLAN_CACHE_PATH}`;
+	let raw;
+	try {
+		raw = __require("node:fs").readFileSync(cachePath, "utf-8");
+		__require("node:fs").unlinkSync(cachePath);
+	} catch {
+		return null;
+	}
+	try {
+		const cached = JSON.parse(raw);
+		if (cached?.mode !== "publish" || !Array.isArray(cached.releases)) return null;
+		const names = /* @__PURE__ */ new Set();
+		for (const r of cached.releases) {
+			if (typeof r.name !== "string" || typeof r.newVersion !== "string") return null;
+			const pkg = packages.get(r.name);
+			if (!pkg || pkg.version !== r.newVersion) {
+				log.dim("  ci plan cache is stale — falling back to registry lookups");
+				return null;
+			}
+			names.add(r.name);
+		}
+		log.dim("  Using cached plan from ci plan");
+		return names;
+	} catch {
+		return null;
+	}
+}
+/**
+* Find unpublished packages, using the ci plan cache if available.
+* Falls back to registry lookups if no cache or cache is invalid.
+*/
+async function findUnpublishedWithCache(rootDir, packages, config) {
+	const cachedNames = loadCachedPlan(rootDir, packages);
+	if (cachedNames) {
+		const unpublished = [];
+		for (const name of cachedNames) {
+			const pkg = packages.get(name);
+			unpublished.push({
+				name,
+				type: "patch",
+				oldVersion: pkg.version,
+				newVersion: pkg.version,
+				bumpFiles: [],
+				isDependencyBump: false,
+				isCascadeBump: false,
+				isGroupBump: false,
+				bumpSources: []
+			});
+		}
+		return unpublished;
+	}
+	return findUnpublishedPackages(packages, config);
+}
+/**
+* Find packages whose current version is not yet published.
+*
+* Detection strategy (per package):
+* 1. Custom `checkPublished` command → run it, compare output to current version
+* 2. `skipNpmPublish` or custom `publishCommand` → check git tags
+* 3. Default → check npm registry via `npm info`
+*/
+async function findUnpublishedPackages(packages, _config) {
+	const unpublished = [];
+	for (const [name, pkg] of packages) {
+		if (pkg.private && !pkg.bumpy?.publishCommand) continue;
+		if (pkg.version === "0.0.0") continue;
+		if (!await checkIfPublished(name, pkg.version, pkg.bumpy)) unpublished.push({
+			name,
+			type: "patch",
+			oldVersion: pkg.version,
+			newVersion: pkg.version,
+			bumpFiles: [],
+			isDependencyBump: false,
+			isCascadeBump: false,
+			isGroupBump: false,
+			bumpSources: []
+		});
+	}
+	return unpublished;
+}
+async function checkIfPublished(name, version, pkgConfig) {
+	const { runAsync, runArgsAsync, tryRunArgs } = await import("./shell-C8KgKnMQ.mjs").then((n) => n.a);
+	if (pkgConfig?.checkPublished) try {
+		return (await runAsync(pkgConfig.checkPublished)).trim() === version;
+	} catch {
+		return false;
+	}
+	if (pkgConfig?.skipNpmPublish || pkgConfig?.publishCommand) {
+		const tag = `${name}@${version}`;
+		return tryRunArgs([
+			"git",
+			"tag",
+			"-l",
+			tag
+		]) === tag;
+	}
+	try {
+		const args = [
+			"npm",
+			"info",
+			`${name}@${version}`,
+			"version"
+		];
+		if (pkgConfig?.registry) args.push("--registry", pkgConfig.registry);
+		return await runArgsAsync(args) === version;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { findUnpublishedPackages, publishCommand };

package/dist/{publish-pipeline-DpmTVsnX.mjs → publish-pipeline-BRnqVylg.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 { r as resolveCatalogDep } from "./package-manager-BQPwXwu5.mjs";
-import { i as stripProtocol } from "./release-plan-s1o52Rc-.mjs";
+import { i as stripProtocol } from "./release-plan-mK7iGeGq.mjs";
 import { i as runAsync, o as sq, r as runArgsAsync, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { t as createTag, u as tagExists } from "./git-CpJqzpp-.mjs";
+import { l as tagExists, t as createTag } from "./git-JGLQtk-M.mjs";
 import { resolve } from "node:path";
 import { unlink } from "node:fs/promises";
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";

package/dist/{release-plan-s1o52Rc-.mjs → release-plan-mK7iGeGq.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-DMdVeeEm.mjs";
-import { s as matchGlob } from "./config-48u1NbKv.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";
 //#region src/core/dep-graph.ts
 var DependencyGraph = class {
 	/** Map from package name → packages that depend on it */

package/dist/{status-BvemGN6p.mjs → status-DeMcLxiM.mjs}

@@ -1,8 +1,8 @@
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
-import { a as loadConfig } from "./config-48u1NbKv.mjs";
-import { o as discoverPackages, r as readBumpFiles, t as filterBranchBumpFiles } from "./bump-file-B_7P2UZO.mjs";
-import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-s1o52Rc-.mjs";
-import { i as getCurrentBranch, r as getChangedFiles } from "./git-CpJqzpp-.mjs";
+import { a as loadConfig } from "./config-D_4GYDJi.mjs";
+import { o as discoverPackages, r as readBumpFiles, t as filterBranchBumpFiles } from "./bump-file-B9DpXK5X.mjs";
+import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-mK7iGeGq.mjs";
+import { i as getCurrentBranch, r as getChangedFiles } from "./git-JGLQtk-M.mjs";
 //#region src/commands/status.ts
 async function statusCommand(rootDir, opts) {
 	const config = await loadConfig(rootDir);
@@ -29,7 +29,7 @@ async function statusCommand(rootDir, opts) {
 		releases = releases.filter((r) => types.includes(r.type));
 	}
 	if (opts.filter) {
-		const { matchGlob } = await import("./config-48u1NbKv.mjs").then((n) => n.t);
+		const { matchGlob } = await import("./config-D_4GYDJi.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)));
 	}

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

@@ -72,7 +72,6 @@ const DEFAULT_CONFIG = {
 	allowCustomCommands: false,
 	packages: {},
 	publish: { ...DEFAULT_PUBLISH_CONFIG },
-	aggregateRelease: false,
 	gitUser: {
 		name: "bumpy-bot",
 		email: "276066384+bumpy-bot@users.noreply.github.com"

package/dist/{version-C7uFKayK.mjs → version-88KuPbWa.mjs}

@@ -1,10 +1,10 @@
 import { n as log, t as colorize } from "./logger-BgksGFuf.mjs";
-import { a as loadConfig } from "./config-48u1NbKv.mjs";
+import { a as loadConfig } from "./config-D_4GYDJi.mjs";
 import { n as detectWorkspaces } from "./package-manager-BQPwXwu5.mjs";
-import { o as discoverPackages, r as readBumpFiles } from "./bump-file-B_7P2UZO.mjs";
-import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-s1o52Rc-.mjs";
+import { o as discoverPackages, r as readBumpFiles } from "./bump-file-B9DpXK5X.mjs";
+import { a as DependencyGraph, t as assembleReleasePlan } from "./release-plan-mK7iGeGq.mjs";
 import { n as runArgs, s as tryRunArgs } from "./shell-C8KgKnMQ.mjs";
-import { t as applyReleasePlan } from "./apply-release-plan-D9wl4Q0H.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-CmjqYo0t.mjs";
 import { t as resolveCommitMessage } from "./commit-message-CSWVKPJ-.mjs";
 //#region src/commands/version.ts
 async function versionCommand(rootDir, opts = {}) {