@ucdjs/release-scripts 0.1.0-beta.34 → 0.1.0-beta.35

package/dist/index.mjs

@@ -1,45 +1,377 @@
-import { t as Eta } from "./eta-BV8TCRDW.mjs";
-import { Console, Context, Data, Effect, Layer, Schema } from "effect";
-import process from "node:process";
-import path from "node:path";
-import { Command, CommandExecutor } from "@effect/platform";
-import { NodeCommandExecutor, NodeFileSystem } from "@effect/platform-node";
-import * as CommitParser from "commit-parser";
-import semver from "semver";
-import fs from "node:fs/promises";
+import { t as Eta } from "./eta-DAZlmVBQ.mjs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import farver from "farver";
 import prompts from "prompts";
+import process from "node:process";
+import readline from "node:readline";
+import mri from "mri";
+import { exec } from "tinyexec";
+import { dedent } from "@luxass/utils";
+import { getCommits, groupByType } from "commit-parser";
+import { compare, gt } from "semver";
 
-//#region src/options.ts
-const DEFAULT_PR_BODY_TEMPLATE = `## Summary\n\nThis PR contains the following changes:\n\n- Updated package versions\n- Updated changelogs\n\n## Packages\n\nThe following packages will be released:\n\n{{packages}}`;
-const DEFAULT_CHANGELOG_TEMPLATE = `# Changelog\n\n{{releases}}`;
-const DEFAULT_TYPES = {
-	feat: {
-		title: "🚀 Features",
-		color: "green"
+//#region src/operations/semver.ts
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function getNextVersion(currentVersion, bump) {
+	if (bump === "none") return currentVersion;
+	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump version for invalid semver: ${currentVersion}`);
+	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
+	const [, major, minor, patch] = match;
+	let newMajor = Number.parseInt(major, 10);
+	let newMinor = Number.parseInt(minor, 10);
+	let newPatch = Number.parseInt(patch, 10);
+	switch (bump) {
+		case "major":
+			newMajor += 1;
+			newMinor = 0;
+			newPatch = 0;
+			break;
+		case "minor":
+			newMinor += 1;
+			newPatch = 0;
+			break;
+		case "patch":
+			newPatch += 1;
+			break;
+	}
+	return `${newMajor}.${newMinor}.${newPatch}`;
+}
+function calculateBumpType(oldVersion, newVersion) {
+	if (!isValidSemver(oldVersion) || !isValidSemver(newVersion)) throw new Error(`Cannot calculate bump type for invalid semver: ${oldVersion} or ${newVersion}`);
+	const oldParts = oldVersion.split(".").map(Number);
+	const newParts = newVersion.split(".").map(Number);
+	if (newParts[0] > oldParts[0]) return "major";
+	if (newParts[1] > oldParts[1]) return "minor";
+	if (newParts[2] > oldParts[2]) return "patch";
+	return "none";
+}
+
+//#endregion
+//#region src/core/prompts.ts
+async function selectPackagePrompt(packages) {
+	const response = await prompts({
+		type: "multiselect",
+		name: "selectedPackages",
+		message: "Select packages to release",
+		choices: packages.map((pkg) => ({
+			title: `${pkg.name} (${farver.bold(pkg.version)})`,
+			value: pkg.name,
+			selected: true
+		})),
+		min: 1,
+		hint: "Space to select/deselect. Return to submit.",
+		instructions: false
+	});
+	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
+	return response.selectedPackages;
+}
+async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion) {
+	const answers = await prompts([{
+		type: "autocomplete",
+		name: "version",
+		message: `${pkg.name}: ${farver.green(pkg.version)}`,
+		choices: [
+			{
+				value: "skip",
+				title: `skip ${farver.dim("(no change)")}`
+			},
+			{
+				value: "major",
+				title: `major ${farver.bold(getNextVersion(pkg.version, "major"))}`
+			},
+			{
+				value: "minor",
+				title: `minor ${farver.bold(getNextVersion(pkg.version, "minor"))}`
+			},
+			{
+				value: "patch",
+				title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
+			},
+			{
+				value: "suggested",
+				title: `suggested ${farver.bold(suggestedVersion)}`
+			},
+			{
+				value: "as-is",
+				title: `as-is ${farver.dim("(keep current version)")}`
+			},
+			{
+				value: "custom",
+				title: "custom"
+			}
+		],
+		initial: suggestedVersion === currentVersion ? 0 : 4
+	}, {
+		type: (prev) => prev === "custom" ? "text" : null,
+		name: "custom",
+		message: "Enter the new version number:",
+		initial: suggestedVersion,
+		validate: (custom) => {
+			if (isValidSemver(custom)) return true;
+			return "That's not a valid version number";
+		}
+	}]);
+	if (!answers.version) return null;
+	if (answers.version === "skip") return null;
+	else if (answers.version === "suggested") return suggestedVersion;
+	else if (answers.version === "custom") {
+		if (!answers.custom) return null;
+		return answers.custom;
+	} else if (answers.version === "as-is") return currentVersion;
+	else return getNextVersion(pkg.version, answers.version);
+}
+
+//#endregion
+//#region src/shared/utils.ts
+const args = mri(process.argv.slice(2));
+const isDryRun = !!args.dry;
+const isVerbose = !!args.verbose;
+const isForce = !!args.force;
+const ucdjsReleaseOverridesPath = ".github/ucdjs-release.overrides.json";
+const isCI = typeof process.env.CI === "string" && process.env.CI !== "" && process.env.CI.toLowerCase() !== "false";
+const logger = {
+	info: (...args) => {
+		console.info(...args);
+	},
+	warn: (...args) => {
+		console.warn(`  ${farver.yellow("⚠")}`, ...args);
+	},
+	error: (...args) => {
+		console.error(`  ${farver.red("✖")}`, ...args);
+	},
+	verbose: (...args) => {
+		if (!isVerbose) return;
+		if (args.length === 0) {
+			console.log();
+			return;
+		}
+		if (args.length > 1 && typeof args[0] === "string") {
+			console.log(farver.dim(args[0]), ...args.slice(1));
+			return;
+		}
+		console.log(...args);
+	},
+	section: (title) => {
+		console.log();
+		console.log(`  ${farver.bold(title)}`);
+		console.log(`  ${farver.gray("─".repeat(title.length + 2))}`);
 	},
-	fix: {
-		title: "🐞 Bug Fixes",
-		color: "red"
+	emptyLine: () => {
+		console.log();
 	},
-	refactor: {
-		title: "🔧 Code Refactoring",
-		color: "blue"
+	item: (message, ...args) => {
+		console.log(`  ${message}`, ...args);
 	},
-	perf: {
-		title: "🏎 Performance",
-		color: "orange"
+	step: (message) => {
+		console.log(`  ${farver.blue("→")} ${message}`);
 	},
-	docs: {
-		title: "📚 Documentation",
-		color: "purple"
+	success: (message) => {
+		console.log(`  ${farver.green("✓")} ${message}`);
 	},
-	style: {
-		title: "🎨 Styles",
-		color: "pink"
+	clearScreen: () => {
+		const repeatCount = process.stdout.rows - 2;
+		const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+		console.log(blank);
+		readline.cursorTo(process.stdout, 0, 0);
+		readline.clearScreenDown(process.stdout);
+	}
+};
+async function run(bin, args, opts = {}) {
+	return exec(bin, args, {
+		throwOnError: true,
+		...opts,
+		nodeOptions: {
+			stdio: "inherit",
+			...opts.nodeOptions
+		}
+	});
+}
+async function dryRun(bin, args, opts) {
+	return logger.verbose(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
+}
+const runIfNotDry = isDryRun ? dryRun : run;
+function exitWithError(message, hint) {
+	logger.error(farver.bold(message));
+	if (hint) console.error(farver.gray(`  ${hint}`));
+	process.exit(1);
+}
+if (isDryRun || isVerbose || isForce) {
+	logger.verbose(farver.inverse(farver.yellow(" Running with special flags ")));
+	logger.verbose({
+		isDryRun,
+		isVerbose,
+		isForce
+	});
+	logger.verbose();
+}
+
+//#endregion
+//#region src/types/result.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+
+//#endregion
+//#region src/core/workspace.ts
+async function discoverWorkspacePackages(workspaceRoot, options) {
+	let workspaceOptions;
+	let explicitPackages;
+	if (options.packages == null || options.packages === true) workspaceOptions = { excludePrivate: false };
+	else if (Array.isArray(options.packages)) {
+		workspaceOptions = {
+			excludePrivate: false,
+			include: options.packages
+		};
+		explicitPackages = options.packages;
+	} else {
+		workspaceOptions = options.packages;
+		if (options.packages.include) explicitPackages = options.packages.include;
+	}
+	let workspacePackages = await findWorkspacePackages(workspaceRoot, workspaceOptions);
+	if (explicitPackages) {
+		const foundNames = new Set(workspacePackages.map((p) => p.name));
+		const missing = explicitPackages.filter((p) => !foundNames.has(p));
+		if (missing.length > 0) exitWithError(`Package${missing.length > 1 ? "s" : ""} not found in workspace: ${missing.join(", ")}`, "Check your package names or run 'pnpm ls' to see available packages");
+	}
+	const isPackagePromptEnabled = options.prompts?.packages !== false;
+	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
+		const selectedNames = await selectPackagePrompt(workspacePackages);
+		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
+	}
+	return workspacePackages;
+}
+function toWorkspaceError(operation, error) {
+	return {
+		type: "workspace",
+		operation,
+		message: error instanceof Error ? error.message : String(error)
+	};
+}
+async function wrapWorkspace(operation, fn) {
+	try {
+		return ok(await fn());
+	} catch (error) {
+		return err(toWorkspaceError(operation, error));
+	}
+}
+function createWorkspaceOperations(overrides = {}) {
+	return { discoverWorkspacePackages: (workspaceRoot, options) => wrapWorkspace("discoverWorkspacePackages", async () => {
+		if (overrides.discoverWorkspacePackages) return overrides.discoverWorkspacePackages(workspaceRoot, options);
+		return discoverWorkspacePackages(workspaceRoot, options);
+	}) };
+}
+async function findWorkspacePackages(workspaceRoot, options) {
+	try {
+		const result = await run("pnpm", [
+			"-r",
+			"ls",
+			"--json"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const rawProjects = JSON.parse(result.stdout);
+		const allPackageNames = new Set(rawProjects.map((p) => p.name));
+		const excludedPackages = /* @__PURE__ */ new Set();
+		const promises = rawProjects.map(async (rawProject) => {
+			const content = await readFile(join(rawProject.path, "package.json"), "utf-8");
+			const packageJson = JSON.parse(content);
+			if (!shouldIncludePackage(packageJson, options)) {
+				excludedPackages.add(rawProject.name);
+				return null;
+			}
+			return {
+				name: rawProject.name,
+				version: rawProject.version,
+				path: rawProject.path,
+				packageJson,
+				workspaceDependencies: Object.keys(rawProject.dependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				}),
+				workspaceDevDependencies: Object.keys(rawProject.devDependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				})
+			};
+		});
+		const packages = await Promise.all(promises);
+		if (excludedPackages.size > 0) logger.info(`Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		return packages.filter((pkg) => pkg !== null);
+	} catch (err) {
+		logger.error("Error discovering workspace packages:", err);
+		throw err;
+	}
+}
+function shouldIncludePackage(pkg, options) {
+	if (!options) return true;
+	if (options.excludePrivate && pkg.private) return false;
+	if (options.include && options.include.length > 0) {
+		if (!options.include.includes(pkg.name)) return false;
 	}
+	if (options.exclude?.includes(pkg.name)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/options.ts
+const DEFAULT_PR_BODY_TEMPLATE = dedent`
+  This PR was automatically generated by the UCD release scripts.
+
+  The following packages have been prepared for release:
+
+  <% if (it.packages.length > 0) { %>
+  <% it.packages.forEach((pkg) => { %>
+  - **<%= pkg.name %>**: <%= pkg.currentVersion %> → <%= pkg.newVersion %> (<%= pkg.bumpType %>)
+  <% }) %>
+  <% } else { %>
+  There are no packages to release.
+  <% } %>
+
+  Please review the changes and merge when ready.
+
+  > [!NOTE]
+  > When this PR is merged, the release process will be triggered automatically, publishing the new package versions to the registry.
+`;
+const DEFAULT_CHANGELOG_TEMPLATE = dedent`
+  <% if (it.previousVersion) { -%>
+  ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
+  <% } else { -%>
+  ## <%= it.version %> (<%= it.date %>)
+  <% } %>
+
+  <% it.groups.forEach((group) => { %>
+  <% if (group.commits.length > 0) { %>
+
+  ### <%= group.title %>
+  <% group.commits.forEach((commit) => { %>
+
+  * <%= commit.line %>
+  <% }); %>
+
+  <% } %>
+  <% }); %>
+`;
+const DEFAULT_TYPES = {
+	feat: { title: "🚀 Features" },
+	fix: { title: "🐞 Bug Fixes" },
+	perf: { title: "🏎 Performance" },
+	docs: { title: "📚 Documentation" },
+	style: { title: "🎨 Styles" }
 };
 function normalizeReleaseScriptsOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false, npm = {}, prompts = {} } = options;
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types, safeguards = true, dryRun = false, npm = {}, prompts = {} } = options;
 	const token = githubToken.trim();
 	if (!token) throw new Error("GitHub token is required. Pass it in via options.");
 	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) throw new Error("Repository (repo) is required. Specify in 'owner/repo' format (e.g., 'octocat/hello-world').");
@@ -63,6 +395,7 @@ function normalizeReleaseScriptsOptions(options) {
 			default: branch.default ?? "main"
 		},
 		globalCommitMode,
+		safeguards,
 		pullRequest: {
 			title: pullRequest.title ?? "chore: release new version",
 			body: pullRequest.body ?? DEFAULT_PR_BODY_TEMPLATE
@@ -72,7 +405,7 @@ function normalizeReleaseScriptsOptions(options) {
 			template: changelog.template ?? DEFAULT_CHANGELOG_TEMPLATE,
 			emojis: changelog.emojis ?? true
 		},
-		types: options.types ? {
+		types: types ? {
 			...DEFAULT_TYPES,
 			...types
 		} : DEFAULT_TYPES,
@@ -80,1916 +413,1645 @@ function normalizeReleaseScriptsOptions(options) {
 			otp: npm.otp,
 			provenance: npm.provenance ?? true
 		},
-		prompts: { versions: prompts.versions ?? !isCI }
+		prompts: {
+			versions: prompts.versions ?? !isCI,
+			packages: prompts.packages ?? !isCI
+		}
 	};
 }
-var ReleaseScriptsOptions = class extends Context.Tag("@ucdjs/release-scripts/ReleaseScriptsOptions")() {};
 
 //#endregion
-//#region src/utils/changelog-formatters.ts
-const eta$1 = new Eta();
+//#region src/operations/changelog-format.ts
+function formatCommitLine({ commit, owner, repo, authors }) {
+	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
+	let line = `${commit.description}`;
+	const references = commit.references ?? [];
+	for (const ref of references) {
+		if (!ref.value) continue;
+		const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
+		if (Number.isNaN(number)) continue;
+		if (ref.type === "issue") {
+			line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
+			continue;
+		}
+		line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
+	}
+	line += ` ([${commit.shortHash}](${commitUrl}))`;
+	if (authors.length > 0) {
+		const authorList = authors.map((author) => author.login ? `[@${author.login}](https://github.com/${author.login})` : author.name).join(", ");
+		line += ` (by ${authorList})`;
+	}
+	return line;
+}
+function buildTemplateGroups(options) {
+	const { commits, owner, repo, types, commitAuthors } = options;
+	const grouped = groupByType(commits, {
+		includeNonConventional: false,
+		mergeKeys: Object.fromEntries(Object.entries(types).map(([key, value]) => [key, value.types ?? [key]]))
+	});
+	return Object.entries(types).map(([key, value]) => {
+		const formattedCommits = (grouped.get(key) ?? []).map((commit) => ({ line: formatCommitLine({
+			commit,
+			owner,
+			repo,
+			authors: commitAuthors.get(commit.hash) ?? []
+		}) }));
+		return {
+			name: key,
+			title: value.title,
+			commits: formattedCommits
+		};
+	});
+}
+
+//#endregion
+//#region src/core/git.ts
 /**
-* Pure function to parse commits into changelog entries
+* Check if the working directory is clean (no uncommitted changes)
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<boolean>} A Promise resolving to true if clean, false otherwise
 */
-function parseCommits(commits) {
-	return commits.filter((commit) => commit.isConventional).filter((commit) => commit.type !== "chore").map((commit) => ({
-		type: commit.type || "other",
-		scope: commit.scope,
-		description: commit.description,
-		breaking: commit.isBreaking || false,
-		hash: commit.hash,
-		shortHash: commit.shortHash,
-		references: commit.references.map((ref) => ({
-			type: ref.type,
-			value: ref.value
-		})),
-		authors: commit.authors.map((author) => ({
-			name: author.name,
-			email: author.email,
-			profile: author.profile
-		}))
-	}));
+async function isWorkingDirectoryClean(workspaceRoot) {
+	try {
+		if ((await run("git", ["status", "--porcelain"], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim() !== "") return false;
+		return true;
+	} catch (err) {
+		logger.error("Error checking git status:", err);
+		return false;
+	}
+}
+function toGitError(operation, error) {
+	return {
+		type: "git",
+		operation,
+		message: error instanceof Error ? error.message : String(error),
+		stderr: (typeof error === "object" && error && "stderr" in error ? String(error.stderr ?? "") : void 0)?.trim() || void 0
+	};
+}
+async function wrapGit(operation, fn) {
+	try {
+		return ok(await fn());
+	} catch (error) {
+		return err(toGitError(operation, error));
+	}
+}
+function createGitOperations(overrides = {}) {
+	return {
+		isWorkingDirectoryClean: (workspaceRoot) => wrapGit("isWorkingDirectoryClean", async () => {
+			if (overrides.isWorkingDirectoryClean) return overrides.isWorkingDirectoryClean(workspaceRoot);
+			return isWorkingDirectoryClean(workspaceRoot);
+		}),
+		doesBranchExist: (branch, workspaceRoot) => wrapGit("doesBranchExist", async () => {
+			if (overrides.doesBranchExist) return overrides.doesBranchExist(branch, workspaceRoot);
+			return doesBranchExist(branch, workspaceRoot);
+		}),
+		getCurrentBranch: (workspaceRoot) => wrapGit("getCurrentBranch", async () => {
+			if (overrides.getCurrentBranch) return overrides.getCurrentBranch(workspaceRoot);
+			return getCurrentBranch(workspaceRoot);
+		}),
+		checkoutBranch: (branch, workspaceRoot) => wrapGit("checkoutBranch", async () => {
+			if (overrides.checkoutBranch) return overrides.checkoutBranch(branch, workspaceRoot);
+			return checkoutBranch(branch, workspaceRoot);
+		}),
+		createBranch: (branch, base, workspaceRoot) => wrapGit("createBranch", async () => {
+			if (overrides.createBranch) {
+				await overrides.createBranch(branch, base, workspaceRoot);
+				return;
+			}
+			await createBranch(branch, base, workspaceRoot);
+		}),
+		pullLatestChanges: (branch, workspaceRoot) => wrapGit("pullLatestChanges", async () => {
+			if (overrides.pullLatestChanges) return overrides.pullLatestChanges(branch, workspaceRoot);
+			return pullLatestChanges(branch, workspaceRoot);
+		}),
+		rebaseBranch: (ontoBranch, workspaceRoot) => wrapGit("rebaseBranch", async () => {
+			if (overrides.rebaseBranch) {
+				await overrides.rebaseBranch(ontoBranch, workspaceRoot);
+				return;
+			}
+			await rebaseBranch(ontoBranch, workspaceRoot);
+		}),
+		isBranchAheadOfRemote: (branch, workspaceRoot) => wrapGit("isBranchAheadOfRemote", async () => {
+			if (overrides.isBranchAheadOfRemote) return overrides.isBranchAheadOfRemote(branch, workspaceRoot);
+			return isBranchAheadOfRemote(branch, workspaceRoot);
+		}),
+		commitChanges: (message, workspaceRoot) => wrapGit("commitChanges", async () => {
+			if (overrides.commitChanges) return overrides.commitChanges(message, workspaceRoot);
+			return commitChanges(message, workspaceRoot);
+		}),
+		pushBranch: (branch, workspaceRoot, options) => wrapGit("pushBranch", async () => {
+			if (overrides.pushBranch) return overrides.pushBranch(branch, workspaceRoot, options);
+			return pushBranch(branch, workspaceRoot, options);
+		}),
+		readFileFromGit: (workspaceRoot, ref, filePath) => wrapGit("readFileFromGit", async () => {
+			if (overrides.readFileFromGit) return overrides.readFileFromGit(workspaceRoot, ref, filePath);
+			return readFileFromGit(workspaceRoot, ref, filePath);
+		}),
+		getMostRecentPackageTag: (workspaceRoot, packageName) => wrapGit("getMostRecentPackageTag", async () => {
+			if (overrides.getMostRecentPackageTag) return overrides.getMostRecentPackageTag(workspaceRoot, packageName);
+			return getMostRecentPackageTag(workspaceRoot, packageName);
+		})
+	};
 }
 /**
-* Pure function to group changelog entries by type
+* Check if a git branch exists locally
+* @param {string} branch - The branch name to check
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<boolean>} Promise resolving to true if branch exists, false otherwise
 */
-function groupByType(entries) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const type = entry.breaking ? "breaking" : entry.type;
-		if (!groups.has(type)) groups.set(type, []);
-		groups.get(type).push(entry);
+async function doesBranchExist(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"rev-parse",
+			"--verify",
+			branch
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		return false;
 	}
-	return groups;
 }
 /**
-* Changelog template for Eta rendering
+* Retrieves the name of the current branch in the repository.
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<string>} A Promise resolving to the current branch name as a string
 */
-const CHANGELOG_ENTRY_TEMPLATE = `## <%= it.version %>
-
-<% if (it.entries.length === 0) { %>
-*No conventional commits found.*
-<% } else { %>
-<% const groups = it.groupedEntries; %>
-<% const typeOrder = ["breaking", "feat", "fix", "perf", "docs", "style", "refactor", "test", "build", "ci", "chore"]; %>
-<% const typeLabels = {
-  breaking: "💥 Breaking Changes",
-  feat: "🚀 Features",
-  fix: "🐞 Bug Fixes",
-  perf: "⚡ Performance",
-  docs: "Documentation",
-  style: "Styling",
-  refactor: "Refactoring",
-  test: "Tests",
-  build: "Build",
-  ci: "CI",
-  chore: "Chores"
-}; %>
-
-<% const formatAuthor = (entry) => {
-  const author = entry.authors && entry.authors.length > 0 ? entry.authors[0] : null;
-  if (!author) return "unknown";
-  if (author.profile && author.profile.includes("github.com/")) {
-    const username = author.profile.split("github.com/")[1];
-    return "@" + username;
-  }
-  return author.name || "unknown";
-}; %>
-
-<% const commitUrl = (hash) => it.repo ? "https://github.com/" + it.repo + "/commit/" + hash : ""; %>
-
-<% const formatLine = (entry) => {
-  const authorText = formatAuthor(entry);
-  const commitLink = commitUrl(entry.hash);
-  const hashPart = commitLink
-    ? " [<samp>(" + entry.shortHash + ")</samp>](" + commitLink + ")"
-    : " <samp>(" + entry.shortHash + ")</samp>";
-  return entry.description + " &nbsp;-&nbsp; by " + authorText + hashPart;
-}; %>
-
-<% for (const type of typeOrder) { %>
-<% const entries = groups.get(type); %>
-<% if (entries && entries.length > 0) { %>
-### &nbsp;&nbsp;&nbsp;<%= typeLabels[type] || type.charAt(0).toUpperCase() + type.slice(1) %>
-
-<% const unscoped = entries.filter(e => !e.scope); %>
-<% const scoped = entries.filter(e => e.scope); %>
-
-<% for (const entry of unscoped) { %>
-- <%= formatLine(entry) %>
-<% } %>
-
-<% const scopes = [...new Set(scoped.map(e => e.scope))]; %>
-<% for (const scope of scopes) { %>
-- **<%= scope %>**:
-  <% const scopeEntries = scoped.filter(e => e.scope === scope); %>
-  <% for (const entry of scopeEntries) { %>
-  - <%= formatLine(entry) %>
-  <% } %>
-<% } %>
-
-<% } %>
-<% } %>
-
-<% for (const [type, entries] of groups) { %>
-<% if (!typeOrder.includes(type)) { %>
-### &nbsp;&nbsp;&nbsp;<%= type.charAt(0).toUpperCase() + type.slice(1) %>
-
-<% for (const entry of entries) { %>
-- <%= formatLine(entry) %>
-<% } %>
-
-<% } %>
-<% } %>
-
-<% if (it.repo) { %>
-##### &nbsp;&nbsp;&nbsp;&nbsp;[View changes on GitHub](https://github.com/<%= it.repo %>/compare/v<%= it.previousVersion %>...v<%= it.version %>)
-<% } %>
-<% } %>`;
+async function getCurrentBranch(workspaceRoot) {
+	try {
+		return (await run("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim();
+	} catch (err) {
+		logger.error("Error getting current branch:", err);
+		throw err;
+	}
+}
 /**
-* Pure function to format changelog as markdown
+* Creates a new branch from the specified base branch.
+* @param {string} branch - The name of the new branch to create
+* @param {string} base - The base branch to create the new branch from
+* @param {string} workspaceRoot - The root directory of the workspace
+* @returns {Promise<void>} A Promise that resolves when the branch is created
 */
-function formatChangelogEntryMarkdown(changelog) {
-	const groups = groupByType(changelog.entries);
-	return eta$1.renderString(CHANGELOG_ENTRY_TEMPLATE, {
-		packageName: changelog.packageName,
-		version: changelog.version,
-		previousVersion: changelog.previousVersion,
-		entries: changelog.entries,
-		groupedEntries: groups,
-		repo: changelog.repo
-	});
+async function createBranch(branch, base, workspaceRoot) {
+	try {
+		logger.info(`Creating branch: ${farver.green(branch)} from ${farver.cyan(base)}`);
+		await runIfNotDry("git", [
+			"branch",
+			branch,
+			base
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+	} catch {
+		exitWithError(`Failed to create branch: ${branch}`, `Make sure the branch doesn't already exist and you have a clean working directory`);
+	}
 }
-function appendChangelogEntry(existingContent, changelogEntry, packageName) {
-	const entry = changelogEntry.trim();
-	if (!entry) return existingContent ?? `# ${packageName}\n`;
-	if (!existingContent || existingContent.trim() === "") return `# ${packageName}\n\n${entry}\n`;
-	const lines = existingContent.split("\n");
-	const firstLine = lines[0]?.trim() ?? "";
-	if (!firstLine.startsWith("# ")) return `# ${packageName}\n\n${entry}\n\n${existingContent.trim()}\n`;
-	let insertIndex = 1;
-	while (insertIndex < lines.length && lines[insertIndex]?.trim() === "") insertIndex++;
-	const rest = lines.slice(insertIndex).join("\n").trim();
-	if (rest) return `${firstLine}\n\n${entry}\n\n${rest}\n`;
-	return `${firstLine}\n\n${entry}\n`;
+async function checkoutBranch(branch, workspaceRoot) {
+	try {
+		logger.info(`Switching to branch: ${farver.green(branch)}`);
+		const match = (await run("git", ["checkout", branch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stderr.trim().match(/Switched to branch '(.+)'/);
+		if (match && match[1] === branch) {
+			logger.info(`Successfully switched to branch: ${farver.green(branch)}`);
+			return true;
+		}
+		return false;
+	} catch {
+		return false;
+	}
+}
+async function pullLatestChanges(branch, workspaceRoot) {
+	try {
+		await run("git", [
+			"pull",
+			"origin",
+			branch
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function rebaseBranch(ontoBranch, workspaceRoot) {
+	try {
+		logger.info(`Rebasing onto: ${farver.cyan(ontoBranch)}`);
+		await runIfNotDry("git", ["rebase", ontoBranch], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		exitWithError(`Failed to rebase onto: ${ontoBranch}`, `You may have merge conflicts. Run 'git rebase --abort' to undo the rebase`);
+	}
+}
+async function isBranchAheadOfRemote(branch, workspaceRoot) {
+	try {
+		const result = await run("git", [
+			"rev-list",
+			`origin/${branch}..${branch}`,
+			"--count"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return Number.parseInt(result.stdout.trim(), 10) > 0;
+	} catch {
+		return true;
+	}
+}
+async function commitChanges(message, workspaceRoot) {
+	try {
+		await run("git", ["add", "."], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		if (await isWorkingDirectoryClean(workspaceRoot)) return false;
+		logger.info(`Committing changes: ${farver.dim(message)}`);
+		await runIfNotDry("git", [
+			"commit",
+			"-m",
+			message
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		exitWithError(`Failed to commit changes`, `Make sure you have git configured properly with user.name and user.email`);
+	}
+}
+async function pushBranch(branch, workspaceRoot, options) {
+	try {
+		const args = [
+			"push",
+			"origin",
+			branch
+		];
+		if (options?.forceWithLease) {
+			args.push("--force-with-lease");
+			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
+		} else if (options?.force) {
+			args.push("--force");
+			logger.info(`Force pushing branch: ${farver.green(branch)}`);
+		} else logger.info(`Pushing branch: ${farver.green(branch)}`);
+		await runIfNotDry("git", args, { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return true;
+	} catch {
+		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
+	}
+}
+async function readFileFromGit(workspaceRoot, ref, filePath) {
+	try {
+		return (await run("git", ["show", `${ref}:${filePath}`], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout;
+	} catch {
+		return null;
+	}
+}
+async function getMostRecentPackageTag(workspaceRoot, packageName) {
+	try {
+		const { stdout } = await run("git", [
+			"tag",
+			"--list",
+			`${packageName}@*`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const tags = stdout.split("\n").map((tag) => tag.trim()).filter(Boolean);
+		if (tags.length === 0) return;
+		return tags.reverse()[0];
+	} catch (err) {
+		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
+		return;
+	}
 }
 /**
-* Pure function to create a changelog object
+* Builds a mapping of commit SHAs to the list of files changed in each commit
+* within a given inclusive range.
+*
+* Internally runs:
+*   git log --name-only --format=%H <from>^..<to>
+*
+* Notes
+* - This includes the commit identified by `from` (via `from^..to`).
+* - Order of commits in the resulting Map follows `git log` output
+*   (reverse chronological, newest first).
+* - On failure (e.g., invalid refs), the function returns null.
+*
+* @param {string} workspaceRoot Absolute path to the git repository root used as cwd.
+* @param {string} from          Starting commit/ref (inclusive).
+* @param {string} to            Ending commit/ref (inclusive).
+* @returns {Promise<Map<string, string[]> | null>} Promise resolving to a Map where keys are commit SHAs and values are
+*          arrays of file paths changed by that commit, or null on error.
 */
-function createChangelog(packageName, version, previousVersion, commits, repo) {
-	return {
+async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
+	const commitsMap = /* @__PURE__ */ new Map();
+	try {
+		const { stdout } = await run("git", [
+			"log",
+			"--name-only",
+			"--format=%H",
+			`${from}^..${to}`
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		const lines = stdout.trim().split("\n").filter((line) => line.trim() !== "");
+		let currentSha = null;
+		const HASH_REGEX = /^[0-9a-f]{40}$/i;
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (HASH_REGEX.test(trimmedLine)) {
+				currentSha = trimmedLine;
+				commitsMap.set(currentSha, []);
+				continue;
+			}
+			if (currentSha === null) continue;
+			commitsMap.get(currentSha).push(trimmedLine);
+		}
+		return commitsMap;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/changelog.ts
+const excludeAuthors = [
+	/\[bot\]/i,
+	/dependabot/i,
+	/\(bot\)/i
+];
+async function generateChangelogEntry(options) {
+	const { packageName, version, previousVersion, date, commits, owner, repo, types, template, githubClient } = options;
+	const templateData = {
 		packageName,
 		version,
 		previousVersion,
-		entries: parseCommits(commits),
-		repo
+		date,
+		compareUrl: previousVersion ? `https://github.com/${owner}/${repo}/compare/${packageName}@${previousVersion}...${packageName}@${version}` : void 0,
+		owner,
+		repo,
+		groups: buildTemplateGroups({
+			commits,
+			owner,
+			repo,
+			types,
+			commitAuthors: await resolveCommitAuthors(commits, githubClient)
+		})
 	};
+	const eta = new Eta();
+	const templateToUse = template || DEFAULT_CHANGELOG_TEMPLATE;
+	return eta.renderString(templateToUse, templateData).trim();
 }
-
-//#endregion
-//#region src/services/changelog.service.ts
-var ChangelogService = class extends Effect.Service()("@ucdjs/release-scripts/ChangelogService", {
-	effect: Effect.gen(function* () {
-		const config = yield* ReleaseScriptsOptions;
-		function generateChangelog(pkg, newVersion, commits) {
-			return Effect.gen(function* () {
-				const changelog = createChangelog(pkg.name, newVersion, pkg.version, commits, `${config.owner}/${config.repo}`);
-				const entryMarkdown = formatChangelogEntryMarkdown(changelog);
-				return {
-					changelog,
-					markdown: appendChangelogEntry(yield* Effect.tryPromise({
-						try: async () => {
-							return await (await import("node:fs/promises")).readFile(`${pkg.path}/CHANGELOG.md`, "utf-8");
-						},
-						catch: (err) => err
-					}).pipe(Effect.catchAll(() => Effect.succeed(""))), entryMarkdown, pkg.name),
-					filePath: `${pkg.path}/CHANGELOG.md`
-				};
+async function updateChangelog(options) {
+	const { version, previousVersion, commits, date, normalizedOptions, workspacePackage, githubClient } = options;
+	const changelogPath = join(workspacePackage.path, "CHANGELOG.md");
+	const changelogRelativePath = relative(normalizedOptions.workspaceRoot, join(workspacePackage.path, "CHANGELOG.md"));
+	const existingContent = await readFileFromGit(normalizedOptions.workspaceRoot, normalizedOptions.branch.default, changelogRelativePath);
+	logger.verbose("Existing content found: ", Boolean(existingContent));
+	const newEntry = await generateChangelogEntry({
+		packageName: workspacePackage.name,
+		version,
+		previousVersion,
+		date,
+		commits,
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		types: normalizedOptions.types,
+		template: normalizedOptions.changelog?.template,
+		githubClient
+	});
+	let updatedContent;
+	if (!existingContent) {
+		updatedContent = `# ${workspacePackage.name}\n\n${newEntry}\n`;
+		await writeFile(changelogPath, updatedContent, "utf-8");
+		return;
+	}
+	const parsed = parseChangelog(existingContent);
+	const lines = existingContent.split("\n");
+	const existingVersionIndex = parsed.versions.findIndex((v) => v.version === version);
+	if (existingVersionIndex !== -1) {
+		const existingVersion = parsed.versions[existingVersionIndex];
+		const before = lines.slice(0, existingVersion.lineStart);
+		const after = lines.slice(existingVersion.lineEnd + 1);
+		updatedContent = [
+			...before,
+			newEntry,
+			...after
+		].join("\n");
+	} else {
+		const insertAt = parsed.headerLineEnd + 1;
+		const before = lines.slice(0, insertAt);
+		const after = lines.slice(insertAt);
+		if (before.length > 0 && before[before.length - 1] !== "") before.push("");
+		updatedContent = [
+			...before,
+			newEntry,
+			"",
+			...after
+		].join("\n");
+	}
+	await writeFile(changelogPath, updatedContent, "utf-8");
+}
+async function resolveCommitAuthors(commits, githubClient) {
+	const authorMap = /* @__PURE__ */ new Map();
+	const commitAuthors = /* @__PURE__ */ new Map();
+	for (const commit of commits) {
+		const authorsForCommit = [];
+		commit.authors.forEach((author, idx) => {
+			if (!author.email || !author.name) return;
+			if (excludeAuthors.some((re) => re.test(author.name))) return;
+			if (!authorMap.has(author.email)) authorMap.set(author.email, {
+				commits: [],
+				name: author.name,
+				email: author.email
 			});
+			const info = authorMap.get(author.email);
+			if (idx === 0) info.commits.push(commit.shortHash);
+			authorsForCommit.push(info);
+		});
+		commitAuthors.set(commit.hash, authorsForCommit);
+	}
+	const authors = Array.from(authorMap.values());
+	await Promise.all(authors.map((info) => githubClient.resolveAuthorInfo(info)));
+	return commitAuthors;
+}
+function parseChangelog(content) {
+	const lines = content.split("\n");
+	let packageName = null;
+	let headerLineEnd = -1;
+	const versions = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("# ")) {
+			packageName = line.slice(2).trim();
+			headerLineEnd = i;
+			break;
 		}
-		return { generateChangelog };
-	}),
-	dependencies: []
-}) {};
-
-//#endregion
-//#region src/services/dependency-graph.service.ts
-var DependencyGraphService = class extends Effect.Service()("@ucdjs/release-scripts/DependencyGraphService", {
-	effect: Effect.gen(function* () {
-		function buildGraph(packages) {
-			const nameToPackage = /* @__PURE__ */ new Map();
-			const adjacency = /* @__PURE__ */ new Map();
-			const inDegree = /* @__PURE__ */ new Map();
-			for (const pkg of packages) {
-				nameToPackage.set(pkg.name, pkg);
-				adjacency.set(pkg.name, /* @__PURE__ */ new Set());
-				inDegree.set(pkg.name, 0);
-			}
-			for (const pkg of packages) {
-				const deps = new Set([...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies]);
-				for (const depName of deps) {
-					if (!nameToPackage.has(depName)) continue;
-					adjacency.get(depName)?.add(pkg.name);
-					inDegree.set(pkg.name, (inDegree.get(pkg.name) ?? 0) + 1);
+	}
+	for (let i = headerLineEnd + 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.startsWith("## ")) {
+			const versionMatch = line.match(/##\s+(?:<small>)?\[?([^\](\s<]+)/);
+			if (versionMatch) {
+				const version = versionMatch[1];
+				const lineStart = i;
+				let lineEnd = lines.length - 1;
+				for (let j = i + 1; j < lines.length; j++) if (lines[j].trim().startsWith("## ")) {
+					lineEnd = j - 1;
+					break;
 				}
+				const versionContent = lines.slice(lineStart, lineEnd + 1).join("\n");
+				versions.push({
+					version,
+					lineStart,
+					lineEnd,
+					content: versionContent
+				});
 			}
-			return {
-				nameToPackage,
-				adjacency,
-				inDegree
-			};
-		}
-		function topologicalOrder(packages) {
-			return Effect.gen(function* () {
-				const { nameToPackage, adjacency, inDegree } = buildGraph(packages);
-				const queue = [];
-				const levels = /* @__PURE__ */ new Map();
-				for (const [name, degree] of inDegree) if (degree === 0) {
-					queue.push(name);
-					levels.set(name, 0);
-				}
-				let queueIndex = 0;
-				const ordered = [];
-				while (queueIndex < queue.length) {
-					const current = queue[queueIndex++];
-					const currentLevel = levels.get(current) ?? 0;
-					const pkg = nameToPackage.get(current);
-					if (pkg) ordered.push({
-						package: pkg,
-						level: currentLevel
-					});
-					for (const neighbor of adjacency.get(current) ?? []) {
-						const nextLevel = currentLevel + 1;
-						if (nextLevel > (levels.get(neighbor) ?? 0)) levels.set(neighbor, nextLevel);
-						const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
-						inDegree.set(neighbor, newDegree);
-						if (newDegree === 0) queue.push(neighbor);
-					}
-				}
-				if (ordered.length !== packages.length) {
-					const processed = new Set(ordered.map((o) => o.package.name));
-					const unprocessed = packages.filter((p) => !processed.has(p.name)).map((p) => p.name);
-					return yield* Effect.fail(/* @__PURE__ */ new Error(`Cycle detected in workspace dependencies. Packages involved: ${unprocessed.join(", ")}`));
-				}
-				return ordered;
-			});
 		}
-		return { topologicalOrder };
-	}),
-	dependencies: []
-}) {};
-
-//#endregion
-//#region src/errors.ts
-var GitCommandError = class extends Data.TaggedError("GitCommandError") {};
-var ExternalCommitParserError = class extends Data.TaggedError("ExternalCommitParserError") {};
-var WorkspaceError = class extends Data.TaggedError("WorkspaceError") {};
-var GitHubError = class extends Data.TaggedError("GitHubError") {};
-var VersionCalculationError = class extends Data.TaggedError("VersionCalculationError") {};
-var OverridesLoadError = class extends Data.TaggedError("OverridesLoadError") {};
-var NPMError = class extends Data.TaggedError("NPMError") {};
-var PublishError = class extends Data.TaggedError("PublishError") {};
-var TagError = class extends Data.TaggedError("TagError") {};
+	}
+	return {
+		packageName,
+		versions,
+		headerLineEnd
+	};
+}
 
 //#endregion
-//#region src/services/git.service.ts
-var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitService", {
-	effect: Effect.gen(function* () {
-		const executor = yield* CommandExecutor.CommandExecutor;
-		const config = yield* ReleaseScriptsOptions;
-		const execGitCommand = (args) => executor.string(Command.make("git", ...args).pipe(Command.workingDirectory(config.workspaceRoot))).pipe(Effect.mapError((err) => {
-			return new GitCommandError({
-				command: `git ${args.join(" ")}`,
-				stderr: err.message
-			});
-		}));
-		const execGitCommandIfNotDry = config.dryRun ? (args) => Effect.succeed(`Dry run mode: skipping git command "git ${args.join(" ")}"`) : execGitCommand;
-		const isWithinRepository = Effect.gen(function* () {
-			return (yield* execGitCommand(["rev-parse", "--is-inside-work-tree"]).pipe(Effect.catchAll(() => Effect.succeed("false")))).trim() === "true";
-		});
-		const listBranches = Effect.gen(function* () {
-			return (yield* execGitCommand(["branch", "--list"])).trim().split("\n").filter((line) => line.length > 0).map((line) => line.replace(/^\* /, "").trim()).map((line) => line.trim());
-		});
-		const isWorkingDirectoryClean = Effect.gen(function* () {
-			return (yield* execGitCommand(["status", "--porcelain"])).trim().length === 0;
+//#region src/core/github.ts
+var GitHubClient = class {
+	owner;
+	repo;
+	githubToken;
+	apiBase = "https://api.github.com";
+	constructor({ owner, repo, githubToken }) {
+		this.owner = owner;
+		this.repo = repo;
+		this.githubToken = githubToken;
+	}
+	async request(path, init = {}) {
+		const url = path.startsWith("http") ? path : `${this.apiBase}${path}`;
+		const res = await fetch(url, {
+			...init,
+			headers: {
+				...init.headers,
+				"Accept": "application/vnd.github.v3+json",
+				"Authorization": `token ${this.githubToken}`,
+				"User-Agent": "ucdjs-release-scripts (+https://github.com/ucdjs/ucdjs-release-scripts)"
+			}
 		});
-		function doesBranchExist(branch) {
-			return listBranches.pipe(Effect.map((branches) => branches.includes(branch)));
+		if (!res.ok) {
+			const errorText = await res.text();
+			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
 		}
-		function createBranch(branch, base = config.branch.default) {
-			return execGitCommandIfNotDry([
-				"branch",
-				branch,
-				base
-			]);
-		}
-		const getBranch = Effect.gen(function* () {
-			return (yield* execGitCommand([
-				"rev-parse",
-				"--abbrev-ref",
-				"HEAD"
-			])).trim();
+		if (res.status === 204) return;
+		return res.json();
+	}
+	async getExistingPullRequest(branch) {
+		const head = branch.includes(":") ? branch : `${this.owner}:${branch}`;
+		const endpoint = `/repos/${this.owner}/${this.repo}/pulls?state=open&head=${encodeURIComponent(head)}`;
+		logger.verbose(`Requesting pull request for branch: ${branch} (url: ${this.apiBase}${endpoint})`);
+		const pulls = await this.request(endpoint);
+		if (!Array.isArray(pulls) || pulls.length === 0) return null;
+		const firstPullRequest = pulls[0];
+		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const pullRequest = {
+			number: firstPullRequest.number,
+			title: firstPullRequest.title,
+			body: firstPullRequest.body,
+			draft: firstPullRequest.draft,
+			html_url: firstPullRequest.html_url,
+			head: "head" in firstPullRequest && typeof firstPullRequest.head === "object" && firstPullRequest.head !== null && "sha" in firstPullRequest.head && typeof firstPullRequest.head.sha === "string" ? { sha: firstPullRequest.head.sha } : void 0
+		};
+		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		return pullRequest;
+	}
+	async upsertPullRequest({ title, body, head, base, pullNumber }) {
+		const isUpdate = typeof pullNumber === "number";
+		const endpoint = isUpdate ? `/repos/${this.owner}/${this.repo}/pulls/${pullNumber}` : `/repos/${this.owner}/${this.repo}/pulls`;
+		const requestBody = isUpdate ? {
+			title,
+			body
+		} : {
+			title,
+			body,
+			head,
+			base,
+			draft: true
+		};
+		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${this.apiBase}${endpoint})`);
+		const pr = await this.request(endpoint, {
+			method: isUpdate ? "PATCH" : "POST",
+			body: JSON.stringify(requestBody)
 		});
-		function checkoutBranch(branch) {
-			return execGitCommand(["checkout", branch]);
-		}
-		function rebaseBranch(onto) {
-			return execGitCommandIfNotDry(["rebase", onto]);
-		}
-		function stageChanges(files) {
-			return Effect.gen(function* () {
-				if (files.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("No files to stage."));
-				return yield* execGitCommandIfNotDry(["add", ...files]);
-			});
-		}
-		function writeCommit(message) {
-			return execGitCommandIfNotDry([
-				"commit",
-				"-m",
-				message
-			]);
-		}
-		function writeEmptyCommit(message) {
-			return execGitCommandIfNotDry([
-				"commit",
-				"--allow-empty",
-				"-m",
-				message
-			]);
-		}
-		function pushChanges(branch, remote = "origin") {
-			return execGitCommandIfNotDry([
-				"push",
-				remote,
-				branch
-			]);
-		}
-		function forcePushChanges(branch, remote = "origin") {
-			return execGitCommandIfNotDry([
-				"push",
-				"--force-with-lease",
-				remote,
-				branch
-			]);
-		}
-		function readFile(filePath, ref = "HEAD") {
-			return execGitCommand(["show", `${ref}:${filePath}`]);
+		if (typeof pr !== "object" || pr === null || !("number" in pr) || typeof pr.number !== "number" || !("title" in pr) || typeof pr.title !== "string" || !("body" in pr) || typeof pr.body !== "string" || !("draft" in pr) || typeof pr.draft !== "boolean" || !("html_url" in pr) || typeof pr.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const action = isUpdate ? "Updated" : "Created";
+		logger.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
+		return {
+			number: pr.number,
+			title: pr.title,
+			body: pr.body,
+			draft: pr.draft,
+			html_url: pr.html_url
+		};
+	}
+	async setCommitStatus({ sha, state, targetUrl, description, context }) {
+		const endpoint = `/repos/${this.owner}/${this.repo}/statuses/${sha}`;
+		logger.verbose(`Setting commit status on ${sha} to ${state} (url: ${this.apiBase}${endpoint})`);
+		await this.request(endpoint, {
+			method: "POST",
+			body: JSON.stringify({
+				state,
+				target_url: targetUrl,
+				description: description || "",
+				context
+			})
+		});
+		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
+	}
+	async resolveAuthorInfo(info) {
+		if (info.login) return info;
+		try {
+			const q = encodeURIComponent(`${info.email} type:user in:email`);
+			const data = await this.request(`/search/users?q=${q}`);
+			if (!data.items || data.items.length === 0) return info;
+			info.login = data.items[0].login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info for email ${info.email}: ${err.message}`);
 		}
-		function getMostRecentPackageTag(packageName) {
-			return execGitCommand([
-				"tag",
-				"--list",
-				"--sort=-version:refname",
-				`${packageName}@*`
-			]).pipe(Effect.map((tags) => {
-				return tags.trim().split("\n").map((tag) => tag.trim()).filter((tag) => tag.length > 0)[0] || null;
-			}), Effect.flatMap((tag) => {
-				if (tag === null) return Effect.succeed(null);
-				return execGitCommand(["rev-parse", tag]).pipe(Effect.map((sha) => ({
-					name: tag,
-					sha: sha.trim()
-				})));
-			}));
+		if (info.login) return info;
+		if (info.commits.length > 0) try {
+			const data = await this.request(`/repos/${this.owner}/${this.repo}/commits/${info.commits[0]}`);
+			if (data.author && data.author.login) info.login = data.author.login;
+		} catch (err) {
+			logger.warn(`Failed to resolve author info from commits for email ${info.email}: ${err.message}`);
 		}
-		function createTag(name, message) {
-			return execGitCommandIfNotDry(message ? [
-				"tag",
-				"-a",
-				name,
-				"-m",
-				message
-			] : ["tag", name]).pipe(Effect.mapError((err) => new TagError({
-				message: `Failed to create tag "${name}"`,
-				tagName: name,
-				operation: "create",
-				cause: err
-			})));
-		}
-		function pushTag(name, remote = "origin") {
-			return execGitCommandIfNotDry([
-				"push",
-				remote,
-				name
-			]).pipe(Effect.mapError((err) => new TagError({
-				message: `Failed to push tag "${name}" to ${remote}`,
-				tagName: name,
-				operation: "push",
-				cause: err
-			})));
-		}
-		function getCommits(options) {
-			return Effect.tryPromise({
-				try: async () => CommitParser.getCommits({
-					from: options?.from,
-					to: options?.to,
-					folder: options?.folder,
-					cwd: config.workspaceRoot
-				}),
-				catch: (e) => new ExternalCommitParserError({
-					message: `commit-parser getCommits`,
-					cause: e instanceof Error ? e.message : String(e)
-				})
-			});
-		}
-		function filesChangesBetweenRefs(from, to) {
-			const commitsMap = /* @__PURE__ */ new Map();
-			return execGitCommand([
-				"log",
-				"--name-only",
-				"--format=%H",
-				`${from}^..${to}`
-			]).pipe(Effect.map((output) => {
-				const lines = output.trim().split("\n").filter((line) => line.trim() !== "");
-				let currentSha = null;
-				const HASH_REGEX = /^[0-9a-f]{40}$/i;
-				for (const line of lines) {
-					const trimmedLine = line.trim();
-					if (HASH_REGEX.test(trimmedLine)) {
-						currentSha = trimmedLine;
-						commitsMap.set(currentSha, []);
-						continue;
-					}
-					if (currentSha === null) continue;
-					commitsMap.get(currentSha).push(trimmedLine);
-				}
-				return commitsMap;
-			}));
-		}
-		const assertWorkspaceReady = Effect.gen(function* () {
-			if (!(yield* isWithinRepository)) return yield* Effect.fail(/* @__PURE__ */ new Error("Not within a Git repository."));
-			if (!(yield* isWorkingDirectoryClean)) return yield* Effect.fail(/* @__PURE__ */ new Error("Working directory is not clean."));
-			return true;
-		});
-		return {
-			branches: {
-				list: listBranches,
-				exists: doesBranchExist,
-				create: createBranch,
-				checkout: checkoutBranch,
-				rebase: rebaseBranch,
-				get: getBranch
-			},
-			commits: {
-				stage: stageChanges,
-				write: writeCommit,
-				writeEmpty: writeEmptyCommit,
-				push: pushChanges,
-				forcePush: forcePushChanges,
-				get: getCommits,
-				filesChangesBetweenRefs
-			},
-			tags: {
-				mostRecentForPackage: getMostRecentPackageTag,
-				create: createTag,
-				push: pushTag
-			},
-			workspace: {
-				readFile,
-				isWithinRepository,
-				isWorkingDirectoryClean,
-				assertWorkspaceReady
+		return info;
+	}
+};
+function createGitHubClient(options) {
+	return new GitHubClient(options);
+}
+function toGitHubError(operation, error) {
+	return {
+		type: "github",
+		operation,
+		message: error instanceof Error ? error.message : String(error)
+	};
+}
+async function wrapGitHub(operation, fn) {
+	try {
+		return ok(await fn());
+	} catch (error) {
+		return err(toGitHubError(operation, error));
+	}
+}
+function createGitHubOperations(options, overrides = {}) {
+	const client = createGitHubClient(options);
+	return {
+		getExistingPullRequest: (branch) => wrapGitHub("getExistingPullRequest", async () => {
+			if (overrides.getExistingPullRequest) return overrides.getExistingPullRequest(branch);
+			return client.getExistingPullRequest(branch);
+		}),
+		upsertPullRequest: (input) => wrapGitHub("upsertPullRequest", async () => {
+			if (overrides.upsertPullRequest) return overrides.upsertPullRequest(input);
+			return client.upsertPullRequest(input);
+		}),
+		setCommitStatus: (input) => wrapGitHub("setCommitStatus", async () => {
+			if (overrides.setCommitStatus) {
+				await overrides.setCommitStatus(input);
+				return;
 			}
-		};
-	}),
-	dependencies: [NodeCommandExecutor.layer]
-}) {};
+			await client.setCommitStatus(input);
+		}),
+		resolveAuthorInfo: (info) => wrapGitHub("resolveAuthorInfo", async () => {
+			if (overrides.resolveAuthorInfo) return overrides.resolveAuthorInfo(info);
+			return client.resolveAuthorInfo(info);
+		})
+	};
+}
+function dedentString(str) {
+	const lines = str.split("\n");
+	const minIndent = lines.filter((line) => line.trim().length > 0).reduce((min, line) => Math.min(min, line.search(/\S/)), Infinity);
+	return lines.map((line) => minIndent === Infinity ? line : line.slice(minIndent)).join("\n").trim();
+}
+function generatePullRequestBody(updates, body) {
+	const eta = new Eta();
+	const bodyTemplate = body ? dedentString(body) : DEFAULT_PR_BODY_TEMPLATE;
+	return eta.renderString(bodyTemplate, { packages: updates.map((u) => ({
+		name: u.package.name,
+		currentVersion: u.currentVersion,
+		newVersion: u.newVersion,
+		bumpType: u.bumpType,
+		hasDirectChanges: u.hasDirectChanges
+	})) });
+}
 
 //#endregion
-//#region src/services/github.service.ts
-const eta = new Eta();
-const PullRequestSchema = Schema.Struct({
-	number: Schema.Number,
-	title: Schema.String,
-	body: Schema.String,
-	head: Schema.Struct({
-		ref: Schema.String,
-		sha: Schema.String
-	}),
-	base: Schema.Struct({
-		ref: Schema.String,
-		sha: Schema.String
-	}),
-	state: Schema.Literal("open", "closed", "merged"),
-	draft: Schema.Boolean,
-	mergeable: Schema.NullOr(Schema.Boolean),
-	url: Schema.String,
-	html_url: Schema.String
-});
-const CreatePullRequestOptionsSchema = Schema.Struct({
-	title: Schema.String,
-	body: Schema.NullOr(Schema.String),
-	head: Schema.String,
-	base: Schema.String,
-	draft: Schema.optional(Schema.Boolean)
-});
-const UpdatePullRequestOptionsSchema = Schema.Struct({
-	title: Schema.optional(Schema.String),
-	body: Schema.optional(Schema.String),
-	state: Schema.optional(Schema.Literal("open", "closed"))
-});
-const CommitStatusSchema = Schema.Struct({
-	state: Schema.Literal("pending", "success", "error", "failure"),
-	target_url: Schema.optional(Schema.String),
-	description: Schema.optional(Schema.String),
-	context: Schema.String
-});
-const RepositoryInfoSchema = Schema.Struct({
-	owner: Schema.String,
-	repo: Schema.String
-});
-var GitHubService = class extends Effect.Service()("@ucdjs/release-scripts/GitHubService", {
-	effect: Effect.gen(function* () {
-		const config = yield* ReleaseScriptsOptions;
-		function makeRequest(endpoint, schema, options = {}) {
-			const url = `https://api.github.com/repos/${config.owner}/${config.repo}/${endpoint}`;
-			return Effect.tryPromise({
-				try: async () => {
-					const res = await fetch(url, {
-						...options,
-						headers: {
-							"Authorization": `token ${config.githubToken}`,
-							"Accept": "application/vnd.github.v3+json",
-							"Content-Type": "application/json",
-							"User-Agent": "ucdjs-release-scripts (https://github.com/ucdjs/release-scripts)",
-							...options.headers
-						}
-					});
-					if (!res.ok) {
-						const text = await res.text();
-						throw new Error(`GitHub API request failed with status ${res.status}: ${text}`);
-					}
-					if (res.status === 204) return;
-					return res.json();
-				},
-				catch: (e) => new GitHubError({
-					message: String(e),
-					operation: "request",
-					cause: e
-				})
-			}).pipe(Effect.flatMap((json) => json === void 0 ? Effect.succeed(void 0) : Schema.decodeUnknown(schema)(json).pipe(Effect.mapError((e) => new GitHubError({
-				message: "Failed to decode GitHub response",
-				operation: "request",
-				cause: e
-			})))));
-		}
-		function getPullRequestByBranch(branch) {
-			const head = branch.includes(":") ? branch : `${config.owner}:${branch}`;
-			return makeRequest(`pulls?state=open&head=${encodeURIComponent(head)}`, Schema.Array(PullRequestSchema)).pipe(Effect.map((pulls) => pulls.length > 0 ? pulls[0] : null), Effect.mapError((e) => new GitHubError({
-				message: e.message,
-				operation: "getPullRequestByBranch",
-				cause: e.cause
-			})));
-		}
-		function setCommitStatus(sha, status) {
-			return makeRequest(`statuses/${sha}`, Schema.Unknown, {
-				method: "POST",
-				body: JSON.stringify(status)
-			}).pipe(Effect.map(() => status), Effect.catchAll((e) => Effect.fail(new GitHubError({
-				message: e.message,
-				operation: "setCommitStatus",
-				cause: e.cause
-			}))));
-		}
-		function updatePullRequest(number, options) {
-			return makeRequest(`pulls/${number}`, PullRequestSchema, {
-				method: "PATCH",
-				body: JSON.stringify(options)
-			}).pipe(Effect.mapError((e) => new GitHubError({
-				message: e.message,
-				operation: "updatePullRequest",
-				cause: e.cause
-			})));
-		}
-		function createPullRequest(options) {
-			return makeRequest("pulls", PullRequestSchema, {
-				method: "POST",
-				body: JSON.stringify(options)
-			}).pipe(Effect.mapError((e) => new GitHubError({
-				message: e.message,
-				operation: "createPullRequest",
-				cause: e.cause
-			})));
-		}
-		const prBodyTemplate = `## Release Summary
-
-This PR prepares the release of <%= it.count %> package<%= it.count === 1 ? "" : "s" %>:
-
-<% for (const release of it.releases) { %>
-- **<%= release.packageName %>**: \`<%= release.previousVersion %>\` → \`<%= release.version %>\`
-<% } %>
+//#region src/operations/branch.ts
+async function prepareReleaseBranch(options) {
+	const { git, workspaceRoot, releaseBranch, defaultBranch } = options;
+	const currentBranch = await git.getCurrentBranch(workspaceRoot);
+	if (!currentBranch.ok) return currentBranch;
+	if (currentBranch.value !== defaultBranch) return err({
+		type: "git",
+		operation: "validateBranch",
+		message: `Current branch is '${currentBranch.value}'. Please switch to '${defaultBranch}'.`
+	});
+	const branchExists = await git.doesBranchExist(releaseBranch, workspaceRoot);
+	if (!branchExists.ok) return branchExists;
+	if (!branchExists.value) {
+		const created = await git.createBranch(releaseBranch, defaultBranch, workspaceRoot);
+		if (!created.ok) return created;
+	}
+	const checkedOut = await git.checkoutBranch(releaseBranch, workspaceRoot);
+	if (!checkedOut.ok) return checkedOut;
+	if (branchExists.value) {
+		const pulled = await git.pullLatestChanges(releaseBranch, workspaceRoot);
+		if (!pulled.ok) return pulled;
+		if (!pulled.value) logger.warn("Failed to pull latest changes, continuing anyway.");
+	}
+	const rebased = await git.rebaseBranch(defaultBranch, workspaceRoot);
+	if (!rebased.ok) return rebased;
+	return ok(void 0);
+}
+async function syncReleaseChanges(options) {
+	const { git, workspaceRoot, releaseBranch, commitMessage, hasChanges } = options;
+	const committed = hasChanges ? await git.commitChanges(commitMessage, workspaceRoot) : ok(false);
+	if (!committed.ok) return committed;
+	const isAhead = await git.isBranchAheadOfRemote(releaseBranch, workspaceRoot);
+	if (!isAhead.ok) return isAhead;
+	if (!committed.value && !isAhead.value) return ok(false);
+	const pushed = await git.pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
+	if (!pushed.ok) return pushed;
+	return ok(true);
+}
 
-## Changes
+//#endregion
+//#region src/operations/calculate.ts
+async function calculateUpdates(options) {
+	const { versioning, workspacePackages, workspaceRoot, showPrompt, overrides, globalCommitMode } = options;
+	const grouped = await versioning.getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
+	if (!grouped.ok) return grouped;
+	const global = await versioning.getGlobalCommitsPerPackage(workspaceRoot, grouped.value, workspacePackages, globalCommitMode);
+	if (!global.ok) return global;
+	const updates = await versioning.calculateAndPrepareVersionUpdates({
+		workspacePackages,
+		packageCommits: grouped.value,
+		workspaceRoot,
+		showPrompt,
+		globalCommitsPerPackage: global.value,
+		overrides
+	});
+	if (!updates.ok) return updates;
+	return updates;
+}
+function ensureHasPackages(packages) {
+	if (packages.length === 0) return err({
+		type: "git",
+		operation: "discoverPackages",
+		message: "No packages found to release"
+	});
+	return {
+		ok: true,
+		value: packages
+	};
+}
 
-See individual package changelogs for details.
-`;
-		function generateReleasePRBody(releases) {
-			return Effect.gen(function* () {
-				return eta.renderString(prBodyTemplate, {
-					count: releases.length,
-					releases
-				});
-			});
-		}
-		return {
-			getPullRequestByBranch,
-			setCommitStatus,
-			createPullRequest,
-			updatePullRequest,
-			generateReleasePRBody
-		};
-	}),
-	dependencies: []
-}) {};
+//#endregion
+//#region src/operations/pr.ts
+async function syncPullRequest(options) {
+	const { github, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody, updates } = options;
+	const existing = await github.getExistingPullRequest(releaseBranch);
+	if (!existing.ok) return existing;
+	const doesExist = !!existing.value;
+	const title = existing.value?.title || pullRequestTitle || "chore: update package versions";
+	const body = generatePullRequestBody(updates, pullRequestBody);
+	const pr = await github.upsertPullRequest({
+		pullNumber: existing.value?.number,
+		title,
+		body,
+		head: releaseBranch,
+		base: defaultBranch
+	});
+	if (!pr.ok) return pr;
+	return ok({
+		pullRequest: pr.value,
+		created: !doesExist
+	});
+}
 
 //#endregion
-//#region src/services/npm.service.ts
-const PackumentSchema = Schema.Struct({
-	"name": Schema.String,
-	"dist-tags": Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	}),
-	"versions": Schema.Record({
-		key: Schema.String,
-		value: Schema.Struct({
-			name: Schema.String,
-			version: Schema.String,
-			description: Schema.optional(Schema.String),
-			dist: Schema.Struct({
-				tarball: Schema.String,
-				shasum: Schema.String,
-				integrity: Schema.optional(Schema.String)
-			})
-		})
-	})
-});
-var NPMService = class extends Effect.Service()("@ucdjs/release-scripts/NPMService", {
-	effect: Effect.gen(function* () {
-		const executor = yield* CommandExecutor.CommandExecutor;
-		const config = yield* ReleaseScriptsOptions;
-		const fetchPackument = (packageName) => Effect.tryPromise({
-			try: async () => {
-				const response = await fetch(`https://registry.npmjs.org/${packageName}`);
-				if (response.status === 404) return null;
-				if (!response.ok) throw new Error(`Failed to fetch packument: ${response.statusText}`);
-				return await response.json();
-			},
-			catch: (error) => {
-				return new NPMError({
-					message: error instanceof Error ? error.message : String(error),
-					operation: "fetchPackument"
-				});
-			}
-		}).pipe(Effect.flatMap((data) => {
-			if (data === null) return Effect.succeed(null);
-			return Schema.decodeUnknown(PackumentSchema)(data).pipe(Effect.mapError((error) => new NPMError({
-				message: `Failed to parse packument: ${error}`,
-				operation: "fetchPackument"
-			})));
-		}));
-		const versionExists = (packageName, version) => fetchPackument(packageName).pipe(Effect.map((packument) => {
-			if (!packument) return false;
-			return version in packument.versions;
-		}));
-		const getLatestVersion = (packageName) => fetchPackument(packageName).pipe(Effect.map((packument) => {
-			if (!packument) return null;
-			return packument["dist-tags"].latest || null;
-		}));
-		const publish = (options) => Effect.gen(function* () {
-			const args = ["publish"];
-			if (options.tagName) args.push("--tag", options.tagName);
-			if (options.otp) args.push("--otp", options.otp);
-			if (options.provenance !== false) args.push("--provenance");
-			if (options.dryRun ?? config.dryRun) args.push("--dry-run");
-			const command = Command.make("pnpm", ...args).pipe(Command.workingDirectory(options.packagePath));
-			return (yield* executor.string(command).pipe(Effect.mapError((err) => new PublishError({
-				message: `Failed to publish package at ${options.packagePath}: ${err.message}`,
-				cause: err
-			})))).trim();
+//#region src/versioning/commits.ts
+/**
+* Get commits grouped by workspace package.
+* For each package, retrieves all commits since its last release tag that affect that package.
+*
+* @param {string} workspaceRoot - The root directory of the workspace
+* @param {WorkspacePackage[]} packages - Array of workspace packages to analyze
+* @returns {Promise<Map<string, GitCommit[]>>} A map of package names to their commits since their last release
+*/
+async function getWorkspacePackageGroupedCommits(workspaceRoot, packages) {
+	const changedPackages = /* @__PURE__ */ new Map();
+	const promises = packages.map(async (pkg) => {
+		const lastTag = await getMostRecentPackageTag(workspaceRoot, pkg.name);
+		const allCommits = await getCommits({
+			from: lastTag,
+			to: "HEAD",
+			cwd: workspaceRoot,
+			folder: pkg.path
 		});
+		logger.verbose(`Found ${farver.cyan(allCommits.length)} commits for package ${farver.bold(pkg.name)} since tag ${farver.cyan(lastTag ?? "N/A")}`);
 		return {
-			fetchPackument,
-			versionExists,
-			getLatestVersion,
-			publish
+			pkgName: pkg.name,
+			commits: allCommits
 		};
-	}),
-	dependencies: [NodeCommandExecutor.layer]
-}) {};
-
-//#endregion
-//#region src/services/workspace.service.ts
-const DependencyRecordSchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.String
-});
-const PnpmDependencySchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.Struct({
-		from: Schema.String,
-		version: Schema.String,
-		resolved: Schema.optional(Schema.String),
-		path: Schema.optional(Schema.String)
-	})
-});
-const PackageJsonSchema = Schema.Struct({
-	name: Schema.String,
-	private: Schema.optional(Schema.Boolean),
-	version: Schema.optional(Schema.String),
-	dependencies: Schema.optional(DependencyRecordSchema),
-	devDependencies: Schema.optional(DependencyRecordSchema),
-	peerDependencies: Schema.optional(DependencyRecordSchema)
-});
-const WorkspacePackageSchema = Schema.Struct({
-	name: Schema.String,
-	version: Schema.String,
-	path: Schema.String,
-	packageJson: PackageJsonSchema,
-	workspaceDependencies: Schema.Array(Schema.String),
-	workspaceDevDependencies: Schema.Array(Schema.String)
-});
-const WorkspaceListSchema = Schema.Array(Schema.Struct({
-	name: Schema.String,
-	path: Schema.String,
-	version: Schema.optional(Schema.String),
-	private: Schema.optional(Schema.Boolean),
-	dependencies: Schema.optional(PnpmDependencySchema),
-	devDependencies: Schema.optional(PnpmDependencySchema),
-	peerDependencies: Schema.optional(PnpmDependencySchema)
-}));
-var WorkspaceService = class extends Effect.Service()("@ucdjs/release-scripts/WorkspaceService", {
-	effect: Effect.gen(function* () {
-		const executor = yield* CommandExecutor.CommandExecutor;
-		const config = yield* ReleaseScriptsOptions;
-		const workspacePackageListOutput = yield* executor.string(Command.make("pnpm", "-r", "ls", "--json").pipe(Command.workingDirectory(config.workspaceRoot))).pipe(Effect.flatMap((stdout) => Effect.try({
-			try: () => JSON.parse(stdout),
-			catch: (e) => new WorkspaceError({
-				message: "Failed to parse pnpm JSON output",
-				operation: "discover",
-				cause: e
-			})
-		})), Effect.flatMap((json) => Schema.decodeUnknown(WorkspaceListSchema)(json).pipe(Effect.mapError((e) => new WorkspaceError({
-			message: "Failed to decode pnpm output",
-			operation: "discover",
-			cause: e
-		})))), Effect.cached);
-		function readPackageJson(pkgPath) {
-			return Effect.tryPromise({
-				try: async () => JSON.parse(await fs.readFile(path.join(pkgPath, "package.json"), "utf8")),
-				catch: (e) => new WorkspaceError({
-					message: `Failed to read package.json for ${pkgPath}`,
-					cause: e,
-					operation: "readPackageJson"
-				})
-			}).pipe(Effect.flatMap((json) => Schema.decodeUnknown(PackageJsonSchema)(json).pipe(Effect.mapError((e) => new WorkspaceError({
-				message: `Invalid package.json for ${pkgPath}`,
-				cause: e,
-				operation: "readPackageJson"
-			})), Effect.map((validated) => ({
-				...json,
-				...validated
-			})))));
-		}
-		function writePackageJson(pkgPath, json) {
-			const fullPath = path.join(pkgPath, "package.json");
-			const content = `${JSON.stringify(json, null, 2)}\n`;
-			if (config.dryRun) return Effect.succeed(`Dry run: skip writing ${fullPath}`);
-			return Effect.tryPromise({
-				try: async () => await fs.writeFile(fullPath, content, "utf8"),
-				catch: (e) => new WorkspaceError({
-					message: `Failed to write package.json for ${pkgPath}`,
-					cause: e,
-					operation: "writePackageJson"
-				})
-			});
+	});
+	const results = await Promise.all(promises);
+	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
+	return changedPackages;
+}
+/**
+* Check if a file path touches any package folder.
+* @param file - The file path to check
+* @param packagePaths - Set of normalized package paths
+* @param workspaceRoot - The workspace root for path normalization
+* @returns true if the file is inside a package folder
+*/
+function fileMatchesPackageFolder(file, packagePaths, workspaceRoot) {
+	const normalizedFile = file.startsWith("./") ? file.slice(2) : file;
+	for (const pkgPath of packagePaths) {
+		const normalizedPkgPath = pkgPath.startsWith(workspaceRoot) ? pkgPath.slice(workspaceRoot.length + 1) : pkgPath;
+		if (normalizedFile.startsWith(`${normalizedPkgPath}/`) || normalizedFile === normalizedPkgPath) return true;
+	}
+	return false;
+}
+/**
+* Check if a commit is a "global" commit (doesn't touch any package folder).
+* @param workspaceRoot - The workspace root
+* @param files - Array of files changed in the commit
+* @param packagePaths - Set of normalized package paths
+* @returns true if this is a global commit
+*/
+function isGlobalCommit(workspaceRoot, files, packagePaths) {
+	if (!files || files.length === 0) return false;
+	return !files.some((file) => fileMatchesPackageFolder(file, packagePaths, workspaceRoot));
+}
+const DEPENDENCY_FILES = [
+	"package.json",
+	"pnpm-lock.yaml",
+	"pnpm-workspace.yaml",
+	"yarn.lock",
+	"package-lock.json"
+];
+/**
+* Find the oldest and newest commits across all packages.
+* @param packageCommits - Map of package commits
+* @returns Object with oldest and newest commit SHAs, or null if no commits
+*/
+function findCommitRange(packageCommits) {
+	let oldestCommit = null;
+	let newestCommit = null;
+	for (const commits of packageCommits.values()) {
+		if (commits.length === 0) continue;
+		const firstCommit = commits[0].shortHash;
+		const lastCommit = commits[commits.length - 1].shortHash;
+		if (!newestCommit) newestCommit = firstCommit;
+		oldestCommit = lastCommit;
+	}
+	if (!oldestCommit || !newestCommit) return null;
+	return {
+		oldest: oldestCommit,
+		newest: newestCommit
+	};
+}
+/**
+* Get global commits for each package based on their individual commit timelines.
+* This solves the problem where packages with different release histories need different global commits.
+*
+* A "global commit" is a commit that doesn't touch any package folder but may affect all packages
+* (e.g., root package.json, CI config, README).
+*
+* Performance: Makes ONE batched git call to get files for all commits across all packages.
+*
+* @param workspaceRoot - The root directory of the workspace
+* @param packageCommits - Map of package name to their commits (from getWorkspacePackageCommits)
+* @param allPackages - All workspace packages (used to identify package folders)
+* @param mode - Filter mode: false (disabled), "all" (all global commits), or "dependencies" (only dependency-related)
+* @returns Map of package name to their global commits
+*/
+async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPackages, mode) {
+	const result = /* @__PURE__ */ new Map();
+	if (!mode) {
+		logger.verbose("Global commits mode disabled");
+		return result;
+	}
+	logger.verbose(`Computing global commits per-package (mode: ${farver.cyan(mode)})`);
+	const commitRange = findCommitRange(packageCommits);
+	if (!commitRange) {
+		logger.verbose("No commits found across packages");
+		return result;
+	}
+	logger.verbose("Fetching files for commits range", `${farver.cyan(commitRange.oldest)}..${farver.cyan(commitRange.newest)}`);
+	const commitFilesMap = await getGroupedFilesByCommitSha(workspaceRoot, commitRange.oldest, commitRange.newest);
+	if (!commitFilesMap) {
+		logger.warn("Failed to get commit file list, returning empty global commits");
+		return result;
+	}
+	logger.verbose("Got file lists for commits", `${farver.cyan(commitFilesMap.size)} commits in ONE git call`);
+	const packagePaths = new Set(allPackages.map((p) => p.path));
+	for (const [pkgName, commits] of packageCommits) {
+		const globalCommitsAffectingPackage = [];
+		logger.verbose("Filtering global commits for package", `${farver.bold(pkgName)} from ${farver.cyan(commits.length)} commits`);
+		for (const commit of commits) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (isGlobalCommit(workspaceRoot, files, packagePaths)) globalCommitsAffectingPackage.push(commit);
 		}
-		const discoverWorkspacePackages = Effect.gen(function* () {
-			let workspaceOptions;
-			let explicitPackages;
-			if (config.packages == null || config.packages === true) workspaceOptions = { excludePrivate: false };
-			else if (Array.isArray(config.packages)) {
-				workspaceOptions = {
-					excludePrivate: false,
-					include: config.packages
-				};
-				explicitPackages = config.packages;
-			} else {
-				workspaceOptions = config.packages;
-				if (config.packages.include) explicitPackages = config.packages.include;
-			}
-			const workspacePackages = yield* findWorkspacePackages(workspaceOptions);
-			if (explicitPackages) {
-				const foundNames = new Set(workspacePackages.map((p) => p.name));
-				const missing = explicitPackages.filter((p) => !foundNames.has(p));
-				if (missing.length > 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Package${missing.length > 1 ? "s" : ""} not found in workspace: ${missing.join(", ")}`));
-			}
-			return workspacePackages;
-		});
-		function findWorkspacePackages(options) {
-			return workspacePackageListOutput.pipe(Effect.flatMap((rawProjects) => {
-				const allPackageNames = new Set(rawProjects.map((p) => p.name));
-				return Effect.all(rawProjects.map((rawProject) => readPackageJson(rawProject.path).pipe(Effect.flatMap((packageJson) => {
-					if (!shouldIncludePackage(packageJson, options)) return Effect.succeed(null);
-					const version = packageJson.version ?? rawProject.version;
-					if (!version) return Effect.logWarning(`Skipping package ${rawProject.name} without version`).pipe(Effect.as(null));
-					const pkg = {
-						name: rawProject.name,
-						version,
-						path: rawProject.path,
-						packageJson,
-						workspaceDependencies: Object.keys(rawProject.dependencies || {}).filter((dep) => allPackageNames.has(dep)),
-						workspaceDevDependencies: Object.keys(rawProject.devDependencies || {}).filter((dep) => allPackageNames.has(dep))
-					};
-					return Schema.decodeUnknown(WorkspacePackageSchema)(pkg).pipe(Effect.mapError((e) => new WorkspaceError({
-						message: `Invalid workspace package structure for ${rawProject.name}`,
-						cause: e,
-						operation: "findWorkspacePackages"
-					})));
-				}), Effect.catchAll(() => {
-					return Effect.logWarning(`Skipping invalid package ${rawProject.name}`).pipe(Effect.as(null));
-				})))).pipe(Effect.map((packages) => packages.filter((pkg) => pkg !== null)));
-			}));
+		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsAffectingPackage.length)} global commits`);
+		if (mode === "all") {
+			result.set(pkgName, globalCommitsAffectingPackage);
+			continue;
 		}
-		function shouldIncludePackage(pkg, options) {
-			if (!options) return true;
-			if (options.excludePrivate && pkg.private) return false;
-			if (options.include && options.include.length > 0) {
-				if (!options.include.includes(pkg.name)) return false;
+		const dependencyCommits = [];
+		for (const commit of globalCommitsAffectingPackage) {
+			const files = commitFilesMap.get(commit.shortHash);
+			if (!files) continue;
+			if (files.some((file) => DEPENDENCY_FILES.includes(file.startsWith("./") ? file.slice(2) : file))) {
+				logger.verbose("Global commit affects dependencies", `${farver.bold(pkgName)}: commit ${farver.cyan(commit.shortHash)} affects dependencies`);
+				dependencyCommits.push(commit);
 			}
-			if (options.exclude?.includes(pkg.name)) return false;
-			return true;
-		}
-		function findPackageByName(packageName) {
-			return discoverWorkspacePackages.pipe(Effect.map((packages) => packages.find((pkg) => pkg.name === packageName) || null));
 		}
-		return {
-			readPackageJson,
-			writePackageJson,
-			findWorkspacePackages,
-			discoverWorkspacePackages,
-			findPackageByName
-		};
-	}),
-	dependencies: []
-}) {};
+		logger.verbose("Global commits affect dependencies", `${farver.bold(pkgName)}: ${farver.cyan(dependencyCommits.length)} global commits affect dependencies`);
+		result.set(pkgName, dependencyCommits);
+	}
+	return result;
+}
 
 //#endregion
-//#region src/services/package-updater.service.ts
-const DASH_RE = / - /;
-const RANGE_OPERATION_RE = /^(?:>=|<=|[><=])/;
-function nextRange(oldRange, newVersion) {
-	const workspacePrefix = oldRange.startsWith("workspace:") ? "workspace:" : "";
-	const raw = workspacePrefix ? oldRange.slice(10) : oldRange;
-	if (raw === "*" || raw === "latest") return `${workspacePrefix}${raw}`;
-	if (raw.includes("||") || DASH_RE.test(raw) || RANGE_OPERATION_RE.test(raw) || raw.includes(" ") && !DASH_RE.test(raw)) {
-		if (semver.satisfies(newVersion, raw)) return `${workspacePrefix}${raw}`;
-		throw new Error(`Cannot update range "${oldRange}" to version ${newVersion}: new version is outside the existing range. Complex range updating is not yet implemented.`);
-	}
-	return `${workspacePrefix}${raw.startsWith("^") || raw.startsWith("~") ? raw[0] : ""}${newVersion}`;
-}
-function updateDependencyRecord(record, releaseMap) {
-	if (!record) return {
-		updated: false,
-		next: void 0
-	};
-	let changed = false;
-	const next = { ...record };
-	for (const [dep, currentRange] of Object.entries(record)) {
-		const bumped = releaseMap.get(dep);
-		if (!bumped) continue;
-		const updatedRange = nextRange(currentRange, bumped);
-		if (updatedRange !== currentRange) {
-			next[dep] = updatedRange;
-			changed = true;
-		}
+//#region src/operations/version.ts
+function determineHighestBump(commits) {
+	if (commits.length === 0) return "none";
+	let highestBump = "none";
+	for (const commit of commits) {
+		const bump = determineBumpType(commit);
+		if (bump === "major") return "major";
+		if (bump === "minor") highestBump = "minor";
+		else if (bump === "patch" && highestBump === "none") highestBump = "patch";
 	}
+	return highestBump;
+}
+function createVersionUpdate(pkg, bump, hasDirectChanges) {
+	const newVersion = getNextVersion(pkg.version, bump);
 	return {
-		updated: changed,
-		next: changed ? next : record
+		package: pkg,
+		currentVersion: pkg.version,
+		newVersion,
+		bumpType: bump,
+		hasDirectChanges
 	};
 }
-var PackageUpdaterService = class extends Effect.Service()("@ucdjs/release-scripts/PackageUpdaterService", {
-	effect: Effect.gen(function* () {
-		const workspace = yield* WorkspaceService;
-		function applyReleases(allPackages, releases) {
-			const releaseMap = /* @__PURE__ */ new Map();
-			for (const release of releases) releaseMap.set(release.package.name, release.newVersion);
-			return Effect.all(allPackages.map((pkg) => Effect.gen(function* () {
-				const releaseVersion = releaseMap.get(pkg.name);
-				const nextJson = { ...pkg.packageJson };
-				let updated = false;
-				if (releaseVersion && pkg.packageJson.version !== releaseVersion) {
-					nextJson.version = releaseVersion;
-					updated = true;
-				}
-				const depsResult = updateDependencyRecord(pkg.packageJson.dependencies, releaseMap);
-				if (depsResult.updated) {
-					nextJson.dependencies = depsResult.next;
-					updated = true;
-				}
-				const devDepsResult = updateDependencyRecord(pkg.packageJson.devDependencies, releaseMap);
-				if (devDepsResult.updated) {
-					nextJson.devDependencies = devDepsResult.next;
-					updated = true;
-				}
-				const peerDepsResult = updateDependencyRecord(pkg.packageJson.peerDependencies, releaseMap);
-				if (peerDepsResult.updated) {
-					nextJson.peerDependencies = peerDepsResult.next;
-					updated = true;
-				}
-				if (!updated) return "skipped";
-				return yield* workspace.writePackageJson(pkg.path, nextJson).pipe(Effect.map(() => "written"));
-			})));
-		}
-		return { applyReleases };
-	}),
-	dependencies: [WorkspaceService.Default]
-}) {};
-
-//#endregion
-//#region src/services/version-calculator.service.ts
-const BUMP_PRIORITY = {
-	none: 0,
-	patch: 1,
-	minor: 2,
-	major: 3
-};
-function maxBump(current, incoming) {
-	return (BUMP_PRIORITY[incoming] ?? 0) > (BUMP_PRIORITY[current] ?? 0) ? incoming : current;
-}
-function bumpFromCommit(commit) {
+function determineBumpType(commit) {
+	if (!commit.isConventional) return "none";
 	if (commit.isBreaking) return "major";
 	if (commit.type === "feat") return "minor";
 	if (commit.type === "fix" || commit.type === "perf") return "patch";
 	return "none";
 }
-function determineBump(commits) {
-	return commits.reduce((acc, commit) => maxBump(acc, bumpFromCommit(commit)), "none");
-}
-var VersionCalculatorService = class extends Effect.Service()("@ucdjs/release-scripts/VersionCalculatorService", {
-	effect: Effect.gen(function* () {
-		function calculateBumps(packages, overrides) {
-			return Effect.all(packages.map((pkg) => Effect.gen(function* () {
-				const bumpType = determineBump([...pkg.commits, ...pkg.globalCommits]);
-				const hasDirectChanges = pkg.commits.length > 0;
-				let nextVersion = null;
-				const override = overrides[pkg.name];
-				if (override) {
-					if (!semver.valid(override)) return yield* Effect.fail(new VersionCalculationError({
-						message: `Invalid override version for ${pkg.name}: ${override}`,
-						packageName: pkg.name
-					}));
-					nextVersion = override;
-				}
-				if (nextVersion === null) if (bumpType === "none") nextVersion = pkg.version;
-				else {
-					const bumped = semver.inc(pkg.version, bumpType);
-					if (!bumped) return yield* Effect.fail(new VersionCalculationError({
-						message: `Failed to bump version for ${pkg.name} using bump type ${bumpType}`,
-						packageName: pkg.name
-					}));
-					nextVersion = bumped;
-				}
-				return {
-					package: {
-						name: pkg.name,
-						version: pkg.version,
-						path: pkg.path,
-						packageJson: pkg.packageJson,
-						workspaceDependencies: pkg.workspaceDependencies,
-						workspaceDevDependencies: pkg.workspaceDevDependencies
-					},
-					currentVersion: pkg.version,
-					newVersion: nextVersion,
-					bumpType,
-					hasDirectChanges
-				};
-			})), { concurrency: 10 });
-		}
-		return { calculateBumps };
-	}),
-	dependencies: []
-}) {};
 
 //#endregion
-//#region src/services/version-prompt.service.ts
-const GREY = "\x1B[90m";
-const RESET = "\x1B[0m";
-const NON_VERSIONING_TYPES = new Set([
-	"chore",
-	"docs",
-	"style",
-	"test",
-	"ci",
-	"build",
-	"refactor"
-]);
-function isVersioningCommit(commit) {
-	return !NON_VERSIONING_TYPES.has(commit.type) || commit.isBreaking;
-}
-function formatCommit(commit) {
-	const isGreyed = !isVersioningCommit(commit);
-	const scope = commit.scope ? `(${commit.scope})` : "";
-	const description = commit.isConventional ? commit.description : commit.message.split("\n")[0] ?? commit.message;
-	const line = `${commit.shortHash}  ${commit.type.padEnd(12)}${scope.padEnd(10)}: ${description}`;
-	return isGreyed ? `${GREY}${line}${RESET}` : line;
-}
-function formatCommits(commits) {
-	if (commits.length === 0) return "  No commits since the last version";
-	const lines = commits.slice(0, 10).map((c) => `  ${formatCommit(c)}`);
-	if (commits.length > 10) lines.push(`  ${GREY}... and ${commits.length - 10} more${RESET}`);
-	return lines.join("\n");
-}
-function getPrereleaseInfo(version) {
-	const parsed = semver.parse(version);
-	if (!parsed) return null;
-	if (parsed.prerelease.length === 0) return null;
-	return {
-		identifier: String(parsed.prerelease[0]),
-		baseVersion: `${parsed.major}.${parsed.minor}.${parsed.patch}`
-	};
-}
-function generateVersionOptions(currentVersion, conventionalBump, prereleaseInfo) {
-	const options = [];
-	const majorVersion = semver.inc(currentVersion, "major");
-	const minorVersion = semver.inc(currentVersion, "minor");
-	const patchVersion = semver.inc(currentVersion, "patch");
-	if (majorVersion) options.push({
-		title: `major ${majorVersion}`,
-		value: {
-			version: majorVersion,
-			bumpType: "major"
-		}
-	});
-	if (minorVersion) options.push({
-		title: `minor ${minorVersion}`,
-		value: {
-			version: minorVersion,
-			bumpType: "minor"
-		}
-	});
-	if (patchVersion) options.push({
-		title: `patch ${patchVersion}`,
-		value: {
-			version: patchVersion,
-			bumpType: "patch"
-		}
-	});
-	if (prereleaseInfo) {
-		const nextPrerelease = semver.inc(currentVersion, "prerelease", prereleaseInfo.identifier);
-		if (nextPrerelease) options.push({
-			title: `next ${nextPrerelease}`,
-			value: {
-				version: nextPrerelease,
-				bumpType: "patch"
-			}
-		});
+//#region src/versioning/package.ts
+/**
+* Build a dependency graph from workspace packages
+*
+* Creates a bidirectional graph that maps:
+* - packages: Map of package name → WorkspacePackage
+* - dependents: Map of package name → Set of packages that depend on it
+*
+* @param packages - All workspace packages
+* @returns Dependency graph with packages and dependents maps
+*/
+function buildPackageDependencyGraph(packages) {
+	const packagesMap = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		packagesMap.set(pkg.name, pkg);
+		dependents.set(pkg.name, /* @__PURE__ */ new Set());
 	}
-	const conventionalVersion = conventionalBump !== "none" ? semver.inc(currentVersion, conventionalBump) : null;
-	if (conventionalVersion) options.push({
-		title: `conventional ${conventionalVersion}`,
-		value: {
-			version: conventionalVersion,
-			bumpType: conventionalBump
+	for (const pkg of packages) {
+		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+		for (const dep of allDeps) {
+			const depSet = dependents.get(dep);
+			if (depSet) depSet.add(pkg.name);
 		}
-	});
-	if (prereleaseInfo) {
-		const prePatch = semver.inc(currentVersion, "prepatch", prereleaseInfo.identifier);
-		const preMinor = semver.inc(currentVersion, "preminor", prereleaseInfo.identifier);
-		const preMajor = semver.inc(currentVersion, "premajor", prereleaseInfo.identifier);
-		if (prePatch) options.push({
-			title: `pre-patch ${prePatch}`,
-			value: {
-				version: prePatch,
-				bumpType: "patch"
-			}
-		});
-		if (preMinor) options.push({
-			title: `pre-minor ${preMinor}`,
-			value: {
-				version: preMinor,
-				bumpType: "minor"
-			}
-		});
-		if (preMajor) options.push({
-			title: `pre-major ${preMajor}`,
-			value: {
-				version: preMajor,
-				bumpType: "major"
-			}
-		});
-	} else {
-		const betaPatch = semver.inc(currentVersion, "prepatch", "beta");
-		const betaMinor = semver.inc(currentVersion, "preminor", "beta");
-		const betaMajor = semver.inc(currentVersion, "premajor", "beta");
-		if (betaPatch) options.push({
-			title: `pre-patch ${betaPatch}`,
-			value: {
-				version: betaPatch,
-				bumpType: "patch"
-			}
-		});
-		if (betaMinor) options.push({
-			title: `pre-minor ${betaMinor}`,
-			value: {
-				version: betaMinor,
-				bumpType: "minor"
-			}
-		});
-		if (betaMajor) options.push({
-			title: `pre-major ${betaMajor}`,
-			value: {
-				version: betaMajor,
-				bumpType: "major"
-			}
-		});
 	}
-	options.push({
-		title: `as-is ${currentVersion}`,
-		value: {
-			version: currentVersion,
-			bumpType: "none"
-		}
-	});
-	options.push({
-		title: "custom ...",
-		value: {
-			version: "custom",
-			bumpType: "none"
-		}
-	});
-	return options;
-}
-function findDefaultIndex(options, conventionalBump) {
-	if (conventionalBump === "none") return 0;
-	const conventionalIndex = options.findIndex((o) => o.title.startsWith("conventional"));
-	return conventionalIndex >= 0 ? conventionalIndex : 0;
-}
-async function promptForCustomVersion(currentVersion) {
-	return (await prompts({
-		type: "text",
-		name: "version",
-		message: `Enter custom version (current: ${currentVersion})`,
-		validate: (input) => {
-			if (!semver.valid(input)) return "Please enter a valid semver version (e.g., 1.2.3)";
-			return true;
-		}
-	})).version || null;
-}
-var VersionPromptService = class extends Effect.Service()("@ucdjs/release-scripts/VersionPromptService", {
-	effect: Effect.gen(function* () {
-		const config = yield* ReleaseScriptsOptions;
-		let applyToAllRemainingChoice = null;
-		let isCancelled = false;
-		function promptForVersion(pkg, conventionalBump, remainingCount) {
-			return Effect.async((resume) => {
-				if (isCancelled) {
-					resume(Effect.succeed({
-						newVersion: pkg.version,
-						bumpType: "none",
-						applyToAllRemaining: false,
-						cancelled: true
-					}));
-					return;
-				}
-				const allCommits = [...pkg.commits, ...pkg.globalCommits];
-				const prereleaseInfo = getPrereleaseInfo(pkg.version);
-				const commitCount = allCommits.length;
-				console.log("");
-				console.log(`${commitCount} commit${commitCount === 1 ? "" : "s"} since the last version:`);
-				console.log(formatCommits(allCommits));
-				console.log("");
-				if (applyToAllRemainingChoice) {
-					const result = {
-						newVersion: applyToAllRemainingChoice.version === "custom" ? pkg.version : applyToAllRemainingChoice.version,
-						bumpType: applyToAllRemainingChoice.bumpType,
-						applyToAllRemaining: false,
-						cancelled: false
-					};
-					resume(Effect.succeed(result));
-					return;
-				}
-				const options = generateVersionOptions(pkg.version, conventionalBump, prereleaseInfo);
-				const defaultIndex = findDefaultIndex(options, conventionalBump);
-				if (remainingCount > 1) options.push({
-					title: "apply-to-all ›",
-					value: {
-						version: "apply-to-all",
-						bumpType: "none"
-					}
-				});
-				prompts({
-					type: "select",
-					name: "choice",
-					message: `Current version ${pkg.version}`,
-					choices: options.map((o) => ({
-						title: o.title,
-						value: o.value
-					})),
-					initial: defaultIndex,
-					hint: "Use arrow keys to navigate, enter to select"
-				}).then(async (response) => {
-					if (!response.choice) {
-						isCancelled = true;
-						const result = {
-							newVersion: pkg.version,
-							bumpType: "none",
-							applyToAllRemaining: false,
-							cancelled: true
-						};
-						resume(Effect.succeed(result));
-						return;
-					}
-					if (response.choice.version === "apply-to-all") {
-						const applyOptions = options.filter((o) => o.value.version !== "custom" && o.value.version !== "apply-to-all");
-						const applyResponse = await prompts({
-							type: "select",
-							name: "choice",
-							message: `Apply to all ${remainingCount} remaining packages`,
-							choices: applyOptions.map((o) => ({
-								title: o.title,
-								value: o.value
-							})),
-							initial: findDefaultIndex(applyOptions, conventionalBump)
-						});
-						if (!applyResponse.choice) {
-							isCancelled = true;
-							resume(Effect.succeed({
-								newVersion: pkg.version,
-								bumpType: "none",
-								applyToAllRemaining: false,
-								cancelled: true
-							}));
-							return;
-						}
-						if (applyResponse.choice.version === "custom") {
-							const customVersion = await promptForCustomVersion(pkg.version);
-							if (!customVersion) {
-								isCancelled = true;
-								resume(Effect.succeed({
-									newVersion: pkg.version,
-									bumpType: "none",
-									applyToAllRemaining: false,
-									cancelled: true
-								}));
-								return;
-							}
-							applyToAllRemainingChoice = {
-								version: customVersion,
-								bumpType: applyResponse.choice.bumpType
-							};
-						} else applyToAllRemainingChoice = applyResponse.choice;
-						const result = {
-							newVersion: applyToAllRemainingChoice?.version || pkg.version,
-							bumpType: applyToAllRemainingChoice?.bumpType || "none",
-							applyToAllRemaining: true,
-							cancelled: false
-						};
-						resume(Effect.succeed(result));
-						return;
-					}
-					let selectedVersion = response.choice.version;
-					const selectedBumpType = response.choice.bumpType;
-					if (selectedVersion === "custom") {
-						const customVersion = await promptForCustomVersion(pkg.version);
-						if (!customVersion) {
-							isCancelled = true;
-							resume(Effect.succeed({
-								newVersion: pkg.version,
-								bumpType: "none",
-								applyToAllRemaining: false,
-								cancelled: true
-							}));
-							return;
-						}
-						selectedVersion = customVersion;
-					}
-					const result = {
-						newVersion: selectedVersion,
-						bumpType: selectedBumpType,
-						applyToAllRemaining: false,
-						cancelled: false
-					};
-					resume(Effect.succeed(result));
-				});
-			});
-		}
-		return {
-			promptForVersion,
-			isEnabled: config.prompts.versions,
-			resetApplyToAll: () => {
-				applyToAllRemainingChoice = null;
-				isCancelled = false;
-			}
-		};
-	}),
-	dependencies: []
-}) {};
-
-//#endregion
-//#region src/utils/helpers.ts
-function loadOverrides(options) {
-	return Effect.gen(function* () {
-		return yield* (yield* GitService).workspace.readFile(options.overridesPath, options.sha).pipe(Effect.flatMap((content) => Effect.try({
-			try: () => JSON.parse(content),
-			catch: (err) => new OverridesLoadError({
-				message: "Failed to parse overrides file.",
-				cause: err
-			})
-		})), Effect.catchAll(() => Effect.succeed({})));
-	});
-}
-const GitCommitSchema = Schema.Struct({
-	isConventional: Schema.Boolean,
-	isBreaking: Schema.Boolean,
-	type: Schema.String,
-	scope: Schema.Union(Schema.String, Schema.Undefined),
-	description: Schema.String,
-	references: Schema.Array(Schema.Struct({
-		type: Schema.Union(Schema.Literal("issue"), Schema.Literal("pull-request")),
-		value: Schema.String
-	})),
-	authors: Schema.Array(Schema.Struct({
-		name: Schema.String,
-		email: Schema.String,
-		profile: Schema.optional(Schema.String)
-	})),
-	hash: Schema.String,
-	shortHash: Schema.String,
-	body: Schema.String,
-	message: Schema.String,
-	date: Schema.String
-});
-const WorkspacePackageWithCommitsSchema = Schema.Struct({
-	...WorkspacePackageSchema.fields,
-	commits: Schema.Array(GitCommitSchema),
-	globalCommits: Schema.Array(GitCommitSchema).pipe(Schema.propertySignature, Schema.withConstructorDefault(() => []))
-});
-function mergePackageCommitsIntoPackages(packages) {
-	return Effect.gen(function* () {
-		const git = yield* GitService;
-		return yield* Effect.forEach(packages, (pkg) => Effect.gen(function* () {
-			const lastTag = yield* git.tags.mostRecentForPackage(pkg.name);
-			const commits = yield* git.commits.get({
-				from: lastTag?.name || void 0,
-				to: "HEAD",
-				folder: pkg.path
-			});
-			const withCommits = {
-				...pkg,
-				commits,
-				globalCommits: []
-			};
-			return yield* Schema.decode(WorkspacePackageWithCommitsSchema)(withCommits).pipe(Effect.mapError((e) => /* @__PURE__ */ new Error(`Failed to decode package with commits for ${pkg.name}: ${e}`)));
-		}));
-	});
+	return {
+		packages: packagesMap,
+		dependents
+	};
 }
 /**
-* Retrieves global commits that affect all packages in a monorepo.
-*
-* This function handles an important edge case in monorepo releases:
-* When pkg-a is released, then a global change is made, and then pkg-b is released,
-* we need to ensure that the global change is only attributed to pkg-a's release,
-* not re-counted for pkg-b.
+* Get all packages affected by changes (including transitive dependents)
 *
-* Algorithm:
-* 1. Find the overall commit range across all packages
-* 2. Fetch all commits and file changes once for this range
-* 3. For each package, filter commits based on its last tag cutoff
-* 4. Apply mode-specific filtering for global commits
+* Uses graph traversal to find all packages that need updates:
+* - Packages with direct changes
+* - All packages that depend on changed packages (transitively)
 *
-* Example scenario:
-* - pkg-a: last released at commit A
-* - global change at commit B (after A)
-* - pkg-b: last released at commit C (after B)
-*
-* Result:
-* - For pkg-a: includes commits from A to HEAD (including B)
-* - For pkg-b: includes commits from C to HEAD (excluding B, since it was already in pkg-b's release range)
+* @param graph - Dependency graph
+* @param changedPackages - Set of package names with direct changes
+* @returns Set of all package names that need updates
+*/
+function getAllAffectedPackages(graph, changedPackages) {
+	const affected = /* @__PURE__ */ new Set();
+	function visitDependents(pkgName) {
+		if (affected.has(pkgName)) return;
+		affected.add(pkgName);
+		const dependents = graph.dependents.get(pkgName);
+		if (dependents) for (const dependent of dependents) visitDependents(dependent);
+	}
+	for (const pkg of changedPackages) visitDependents(pkg);
+	return affected;
+}
+/**
+* Create version updates for all packages affected by dependency changes
 *
-* @param packages - Array of workspace packages with their associated commits
-* @param mode - Determines which global commits to include:
-*   - "none": No global commits (returns empty map)
-*   - "all": All commits that touch files outside any package directory
-*   - "dependencies": Only commits that touch dependency-related files (package.json, lock files, etc.)
+* When a package is updated, all packages that depend on it should also be updated.
+* This function calculates which additional packages need patch bumps due to dependency changes.
 *
-* @returns A map of package names to their relevant global commits
+* @param graph - Dependency graph
+* @param workspacePackages - All workspace packages
+* @param directUpdates - Packages with direct code changes
+* @returns All updates including dependent packages that need patch bumps
 */
-function mergeCommitsAffectingGloballyIntoPackage(packages, mode) {
-	return Effect.gen(function* () {
-		const git = yield* GitService;
-		if (mode === "none") return packages;
-		const [oldestCommitSha, newestCommitSha] = findCommitRange(packages);
-		if (oldestCommitSha == null || newestCommitSha == null) return packages;
-		const allCommits = yield* git.commits.get({
-			from: oldestCommitSha,
-			to: newestCommitSha,
-			folder: "."
-		});
-		const affectedFilesPerCommit = yield* git.commits.filesChangesBetweenRefs(oldestCommitSha, newestCommitSha);
-		const commitTimestamps = new Map(allCommits.map((c) => [c.hash, new Date(c.date).getTime()]));
-		const packagePaths = new Set(packages.map((p) => p.path));
-		const result = /* @__PURE__ */ new Map();
-		for (const pkg of packages) {
-			const lastTag = yield* git.tags.mostRecentForPackage(pkg.name);
-			const cutoffTimestamp = lastTag ? commitTimestamps.get(lastTag.sha) ?? 0 : 0;
-			const globalCommits = [];
-			for (const commit of allCommits) {
-				const commitTimestamp = commitTimestamps.get(commit.hash);
-				if (commitTimestamp == null || commitTimestamp <= cutoffTimestamp) continue;
-				const files = affectedFilesPerCommit.get(commit.hash);
-				if (!files) continue;
-				if (isGlobalCommit(files, packagePaths)) if (mode === "dependencies") {
-					if (files.some((file) => isDependencyFile(file))) globalCommits.push(commit);
-				} else globalCommits.push(commit);
+function createDependentUpdates(graph, workspacePackages, directUpdates) {
+	const allUpdates = [...directUpdates];
+	const directUpdateMap = new Map(directUpdates.map((u) => [u.package.name, u]));
+	const affectedPackages = getAllAffectedPackages(graph, new Set(directUpdates.map((u) => u.package.name)));
+	for (const pkgName of affectedPackages) {
+		logger.verbose(`Processing affected package: ${pkgName}`);
+		if (directUpdateMap.has(pkgName)) {
+			logger.verbose(`Skipping ${pkgName}, already has a direct update`);
+			continue;
+		}
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		allUpdates.push(createVersionUpdate(pkg, "patch", false));
+	}
+	return allUpdates;
+}
+
+//#endregion
+//#region src/versioning/version.ts
+const messageColorMap = {
+	feat: farver.green,
+	feature: farver.green,
+	refactor: farver.cyan,
+	style: farver.cyan,
+	docs: farver.blue,
+	doc: farver.blue,
+	types: farver.blue,
+	type: farver.blue,
+	chore: farver.gray,
+	ci: farver.gray,
+	build: farver.gray,
+	deps: farver.gray,
+	dev: farver.gray,
+	fix: farver.yellow,
+	test: farver.yellow,
+	perf: farver.magenta,
+	revert: farver.red,
+	breaking: farver.red
+};
+function formatCommitsForDisplay(commits) {
+	if (commits.length === 0) return farver.dim("No commits found");
+	const maxCommitsToShow = 10;
+	const commitsToShow = commits.slice(0, maxCommitsToShow);
+	const hasMore = commits.length > maxCommitsToShow;
+	const typeLength = commits.map(({ type }) => type.length).reduce((a, b) => Math.max(a, b), 0);
+	const scopeLength = commits.map(({ scope }) => scope?.length).reduce((a, b) => Math.max(a || 0, b || 0), 0) || 0;
+	const formattedCommits = commitsToShow.map((commit) => {
+		let color = messageColorMap[commit.type] || ((c) => c);
+		if (commit.isBreaking) color = (s) => farver.inverse.red(s);
+		const paddedType = commit.type.padStart(typeLength + 1, " ");
+		const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : farver.dim("(") + commit.scope + farver.dim(")") + " ".repeat(scopeLength - commit.scope.length);
+		return [
+			farver.dim(commit.shortHash),
+			" ",
+			color === farver.gray ? color(paddedType) : farver.bold(color(paddedType)),
+			" ",
+			paddedScope,
+			farver.dim(":"),
+			" ",
+			color === farver.gray ? color(commit.description) : commit.description
+		].join("");
+	}).join("\n");
+	if (hasMore) return `${formattedCommits}\n  ${farver.dim(`... and ${commits.length - maxCommitsToShow} more commits`)}`;
+	return formattedCommits;
+}
+async function calculateVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides: initialOverrides = {} }) {
+	const versionUpdates = [];
+	const processedPackages = /* @__PURE__ */ new Set();
+	const newOverrides = { ...initialOverrides };
+	const bumpRanks = {
+		major: 3,
+		minor: 2,
+		patch: 1,
+		none: 0
+	};
+	logger.verbose(`Starting version inference for ${packageCommits.size} packages with commits`);
+	for (const [pkgName, pkgCommits] of packageCommits) {
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) {
+			logger.error(`Package ${pkgName} not found in workspace packages, skipping`);
+			continue;
+		}
+		processedPackages.add(pkgName);
+		const globalCommits = globalCommitsPerPackage.get(pkgName) || [];
+		const allCommitsForPackage = [...pkgCommits, ...globalCommits];
+		const determinedBump = determineHighestBump(allCommitsForPackage);
+		const override = newOverrides[pkgName];
+		const effectiveBump = override?.type || determinedBump;
+		if (effectiveBump === "none") continue;
+		let newVersion = override?.version || getNextVersion(pkg.version, effectiveBump);
+		let finalBumpType = effectiveBump;
+		if (!isCI && showPrompt) {
+			logger.clearScreen();
+			logger.section(`📝 Commits for ${farver.cyan(pkg.name)}`);
+			formatCommitsForDisplay(allCommitsForPackage).split("\n").forEach((line) => logger.item(line));
+			logger.emptyLine();
+			const selectedVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, newVersion);
+			if (selectedVersion === null) continue;
+			const userBump = calculateBumpType(pkg.version, selectedVersion);
+			finalBumpType = userBump;
+			if (bumpRanks[userBump] < bumpRanks[determinedBump]) {
+				newOverrides[pkgName] = {
+					type: userBump,
+					version: selectedVersion
+				};
+				logger.info(`Version override recorded for ${pkgName}: ${determinedBump} → ${userBump}`);
+			} else if (newOverrides[pkgName] && bumpRanks[userBump] >= bumpRanks[determinedBump]) {
+				delete newOverrides[pkgName];
+				logger.info(`Version override removed for ${pkgName}.`);
 			}
-			result.set(pkg.name, globalCommits);
+			newVersion = selectedVersion;
 		}
-		return yield* Effect.succeed(packages.map((pkg) => ({
-			...pkg,
-			globalCommits: result.get(pkg.name) || []
-		})));
-	});
+		versionUpdates.push({
+			package: pkg,
+			currentVersion: pkg.version,
+			newVersion,
+			bumpType: finalBumpType,
+			hasDirectChanges: allCommitsForPackage.length > 0
+		});
+	}
+	if (!isCI && showPrompt) for (const pkg of workspacePackages) {
+		if (processedPackages.has(pkg.name)) continue;
+		logger.clearScreen();
+		logger.section(`📦 Package: ${pkg.name}`);
+		logger.item("No direct commits found");
+		const newVersion = await selectVersionPrompt(workspaceRoot, pkg, pkg.version, pkg.version);
+		if (newVersion === null) break;
+		if (newVersion !== pkg.version) {
+			const bumpType = calculateBumpType(pkg.version, newVersion);
+			versionUpdates.push({
+				package: pkg,
+				currentVersion: pkg.version,
+				newVersion,
+				bumpType,
+				hasDirectChanges: false
+			});
+		}
+	}
+	return {
+		updates: versionUpdates,
+		overrides: newOverrides
+	};
 }
 /**
-* Determines if a commit is "global" (affects files outside any package directory).
-*
-* @param files - List of files changed in the commit
-* @param packagePaths - Set of package directory paths
-* @returns true if at least one file is outside all package directories
+* Calculate version updates and prepare dependent updates
+* Returns both the updates and a function to apply them
 */
-function isGlobalCommit(files, packagePaths) {
-	return files.some((file) => {
-		const normalized = file.startsWith("./") ? file.slice(2) : file;
-		for (const pkgPath of packagePaths) if (normalized === pkgPath || normalized.startsWith(`${pkgPath}/`)) return false;
-		return true;
+async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides }) {
+	const { updates: directUpdates, overrides: newOverrides } = await calculateVersionUpdates({
+		workspacePackages,
+		packageCommits,
+		workspaceRoot,
+		showPrompt,
+		globalCommitsPerPackage,
+		overrides
 	});
+	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, directUpdates);
+	const applyUpdates = async () => {
+		await Promise.all(allUpdates.map(async (update) => {
+			const depUpdates = getDependencyUpdates(update.package, allUpdates);
+			await updatePackageJson(update.package, update.newVersion, depUpdates);
+		}));
+	};
+	return {
+		allUpdates,
+		applyUpdates,
+		overrides: newOverrides
+	};
 }
-/**
-* Files that are considered dependency-related in a monorepo.
-*/
-const DEPENDENCY_FILES = new Set([
-	"package.json",
-	"pnpm-lock.yaml",
-	"yarn.lock",
-	"package-lock.json",
-	"pnpm-workspace.yaml"
-]);
-/**
-* Determines if a file is dependency-related.
-*
-* @param file - File path to check
-* @returns true if the file is a dependency file (package.json, lock files, etc.)
-*/
-function isDependencyFile(file) {
-	const normalized = file.startsWith("./") ? file.slice(2) : file;
-	if (DEPENDENCY_FILES.has(normalized)) return true;
-	return Array.from(DEPENDENCY_FILES).some((dep) => normalized.endsWith(`/${dep}`));
+async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
+	const packageJsonPath = join(pkg.path, "package.json");
+	const content = await readFile(packageJsonPath, "utf-8");
+	const packageJson = JSON.parse(content);
+	packageJson.version = newVersion;
+	function updateDependency(deps, depName, depVersion, isPeerDependency = false) {
+		if (!deps) return;
+		const oldVersion = deps[depName];
+		if (!oldVersion) return;
+		if (oldVersion === "workspace:*") {
+			logger.verbose(`  - Skipping workspace:* dependency: ${depName}`);
+			return;
+		}
+		if (isPeerDependency) {
+			const majorVersion = depVersion.split(".")[0];
+			deps[depName] = `>=${depVersion} <${Number(majorVersion) + 1}.0.0`;
+		} else deps[depName] = `^${depVersion}`;
+		logger.verbose(`  - Updated dependency ${depName}: ${oldVersion} → ${deps[depName]}`);
+	}
+	for (const [depName, depVersion] of dependencyUpdates) {
+		updateDependency(packageJson.dependencies, depName, depVersion);
+		updateDependency(packageJson.devDependencies, depName, depVersion);
+		updateDependency(packageJson.peerDependencies, depName, depVersion, true);
+	}
+	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+	logger.verbose(`  - Successfully wrote updated package.json`);
 }
 /**
-* Finds the oldest and newest commits across all packages.
-*
-* This establishes the overall time range we need to analyze for global commits.
-*
-* @param packages - Array of packages with their commits
-* @returns Tuple of [oldestCommitSha, newestCommitSha], or [null, null] if no commits found
+* Get all dependency updates needed for a package
 */
-function findCommitRange(packages) {
-	let oldestCommit = null;
-	let newestCommit = null;
-	for (const pkg of packages) {
-		if (pkg.commits.length === 0) continue;
-		const firstCommit = pkg.commits[0];
-		if (!firstCommit) throw new Error(`No commits found for package ${pkg.name}`);
-		const lastCommit = pkg.commits[pkg.commits.length - 1];
-		if (!lastCommit) throw new Error(`No commits found for package ${pkg.name}`);
-		if (newestCommit == null || new Date(lastCommit.date) > new Date(newestCommit.date)) newestCommit = lastCommit;
-		if (oldestCommit == null || new Date(firstCommit.date) < new Date(oldestCommit.date)) oldestCommit = firstCommit;
+function getDependencyUpdates(pkg, allUpdates) {
+	const updates = /* @__PURE__ */ new Map();
+	const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+	for (const dep of allDeps) {
+		const update = allUpdates.find((u) => u.package.name === dep);
+		if (update) {
+			logger.verbose(`  - Dependency ${dep} will be updated: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
+			updates.set(dep, update.newVersion);
+		}
 	}
-	if (oldestCommit == null || newestCommit == null) return [null, null];
-	return [oldestCommit.hash, newestCommit.hash];
+	if (updates.size === 0) logger.verbose(`  - No dependency updates needed`);
+	return updates;
 }
 
 //#endregion
-//#region src/prepare.ts
-function constructPrepareProgram(config) {
-	return Effect.gen(function* () {
-		const changelog = yield* ChangelogService;
-		const git = yield* GitService;
-		const github = yield* GitHubService;
-		const dependencyGraph = yield* DependencyGraphService;
-		const packageUpdater = yield* PackageUpdaterService;
-		const versionCalculator = yield* VersionCalculatorService;
-		const versionPrompt = yield* VersionPromptService;
-		const workspace = yield* WorkspaceService;
-		yield* git.workspace.assertWorkspaceReady;
-		const startingBranch = yield* git.branches.get;
-		if (startingBranch !== config.branch.default) return yield* Effect.fail(/* @__PURE__ */ new Error(`Prepare must be run on the default branch "${config.branch.default}". Current branch: "${startingBranch}"`));
-		let releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
-		const isNewRelease = !releasePullRequest;
-		const branchExists = yield* git.branches.exists(config.branch.release);
-		if (!branchExists) {
-			yield* Console.log(`Creating release branch "${config.branch.release}" from "${config.branch.default}"...`);
-			yield* git.branches.create(config.branch.release, config.branch.default);
-			yield* Console.log(`Release branch created.`);
-		}
-		if ((yield* git.branches.get) !== config.branch.release) {
-			yield* git.branches.checkout(config.branch.release);
-			yield* Console.log(`Checked out to release branch "${config.branch.release}".`);
+//#region src/versioning/operations.ts
+function createVersioningOperations() {
+	return {
+		getWorkspacePackageGroupedCommits: async (workspaceRoot, packages) => {
+			try {
+				return {
+					ok: true,
+					value: await getWorkspacePackageGroupedCommits(workspaceRoot, packages)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						type: "git",
+						operation: "getWorkspacePackageGroupedCommits",
+						message: String(error)
+					}
+				};
+			}
+		},
+		getGlobalCommitsPerPackage: async (workspaceRoot, packageCommits, packages, mode) => {
+			try {
+				return {
+					ok: true,
+					value: await getGlobalCommitsPerPackage(workspaceRoot, packageCommits, packages, mode)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						type: "git",
+						operation: "getGlobalCommitsPerPackage",
+						message: String(error)
+					}
+				};
+			}
+		},
+		calculateAndPrepareVersionUpdates: async (payload) => {
+			try {
+				return {
+					ok: true,
+					value: await calculateAndPrepareVersionUpdates(payload)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						type: "git",
+						operation: "calculateAndPrepareVersionUpdates",
+						message: String(error)
+					}
+				};
+			}
 		}
-		if (!isNewRelease || branchExists) {
-			yield* Console.log(`Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
-			yield* git.branches.rebase(config.branch.default);
-			yield* Console.log(`Rebase complete.`);
+	};
+}
+
+//#endregion
+//#region src/workflows/prepare.ts
+async function prepareWorkflow(options) {
+	const gitOps = createGitOperations();
+	const githubOps = createGitHubOperations({
+		owner: options.owner,
+		repo: options.repo,
+		githubToken: options.githubToken
+	});
+	const workspaceOps = createWorkspaceOperations();
+	const versioningOps = createVersioningOperations();
+	if (options.safeguards) {
+		const clean = await gitOps.isWorkingDirectoryClean(options.workspaceRoot);
+		if (!clean.ok || !clean.value) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	}
+	const discovered = await workspaceOps.discoverWorkspacePackages(options.workspaceRoot, options);
+	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
+	const ensured = ensureHasPackages(discovered.value);
+	if (!ensured.ok) {
+		logger.warn(ensured.error.message);
+		return null;
+	}
+	const workspacePackages = ensured.value;
+	logger.section("📦 Workspace Packages");
+	logger.item(`Found ${workspacePackages.length} packages`);
+	for (const pkg of workspacePackages) {
+		logger.item(`${farver.cyan(pkg.name)} (${farver.bold(pkg.version)})`);
+		logger.item(`  ${farver.gray("→")} ${farver.gray(pkg.path)}`);
+	}
+	logger.emptyLine();
+	const prepareBranchResult = await prepareReleaseBranch({
+		git: gitOps,
+		workspaceRoot: options.workspaceRoot,
+		releaseBranch: options.branch.release,
+		defaultBranch: options.branch.default
+	});
+	if (!prepareBranchResult.ok) exitWithError(prepareBranchResult.error.message);
+	const overridesPath = join(options.workspaceRoot, ucdjsReleaseOverridesPath);
+	let existingOverrides = {};
+	try {
+		const overridesContent = await readFile(overridesPath, "utf-8");
+		existingOverrides = JSON.parse(overridesContent);
+		logger.info("Found existing version overrides file.");
+	} catch {
+		logger.info("No existing version overrides file found. Continuing...");
+	}
+	const updatesResult = await calculateUpdates({
+		versioning: versioningOps,
+		workspacePackages,
+		workspaceRoot: options.workspaceRoot,
+		showPrompt: options.prompts?.versions !== false,
+		globalCommitMode: options.globalCommitMode === "none" ? false : options.globalCommitMode,
+		overrides: existingOverrides
+	});
+	if (!updatesResult.ok) exitWithError(updatesResult.error.message);
+	const { allUpdates, applyUpdates, overrides: newOverrides } = updatesResult.value;
+	if (Object.keys(newOverrides).length > 0) {
+		logger.info("Writing version overrides file...");
+		try {
+			await mkdir(join(options.workspaceRoot, ".github"), { recursive: true });
+			await writeFile(overridesPath, JSON.stringify(newOverrides, null, 2), "utf-8");
+			logger.success("Successfully wrote version overrides file.");
+		} catch (e) {
+			logger.error("Failed to write version overrides file:", e);
 		}
-		const overrides = yield* loadOverrides({
-			sha: config.branch.default,
-			overridesPath: ".github/ucdjs-release.overrides.json"
-		});
-		if (Object.keys(overrides).length > 0) yield* Console.log("Loaded version overrides:", overrides);
-		const originalBranch = yield* git.branches.get;
-		yield* git.branches.checkout(config.branch.default);
-		const packages = yield* workspace.discoverWorkspacePackages.pipe(Effect.flatMap(mergePackageCommitsIntoPackages), Effect.flatMap((pkgs) => mergeCommitsAffectingGloballyIntoPackage(pkgs, config.globalCommitMode)));
-		yield* Console.log(`Discovered ${packages.length} packages with commits.`);
-		yield* dependencyGraph.topologicalOrder(packages);
-		const releases = [];
-		if (versionPrompt.isEnabled) {
-			yield* Console.log("\nInteractive version selection enabled.\n");
-			versionPrompt.resetApplyToAll();
-			for (let i = 0; i < packages.length; i++) {
-				const pkg = packages[i];
-				const conventionalBump = determineBump([...pkg.commits, ...pkg.globalCommits]);
-				const remainingCount = packages.length - i;
-				const override = overrides[pkg.name];
-				if (override) {
-					if (!semver.valid(override)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Invalid override version for ${pkg.name}: ${override}`));
-					releases.push({
-						package: {
-							name: pkg.name,
-							version: pkg.version,
-							path: pkg.path,
-							packageJson: pkg.packageJson,
-							workspaceDependencies: pkg.workspaceDependencies,
-							workspaceDevDependencies: pkg.workspaceDevDependencies
-						},
-						currentVersion: pkg.version,
-						newVersion: override,
-						bumpType: "none",
-						hasDirectChanges: pkg.commits.length > 0
-					});
-					continue;
-				}
-				const result = yield* versionPrompt.promptForVersion(pkg, conventionalBump, remainingCount);
-				if (result.cancelled) {
-					yield* Console.log("\nCancelled by user.");
-					if (startingBranch !== (yield* git.branches.get)) {
-						yield* git.branches.checkout(startingBranch);
-						yield* Console.log(`Switched back to "${startingBranch}".`);
-					}
-					return yield* Effect.fail(/* @__PURE__ */ new Error("Release preparation cancelled."));
+	}
+	if (Object.keys(newOverrides).length === 0 && Object.keys(existingOverrides).length > 0) {
+		let shouldRemoveOverrides = false;
+		for (const update of allUpdates) {
+			const overriddenVersion = existingOverrides[update.package.name];
+			if (overriddenVersion) {
+				if (compare(update.newVersion, overriddenVersion.version) > 0) {
+					shouldRemoveOverrides = true;
+					break;
 				}
-				releases.push({
-					package: {
-						name: pkg.name,
-						version: pkg.version,
-						path: pkg.path,
-						packageJson: pkg.packageJson,
-						workspaceDependencies: pkg.workspaceDependencies,
-						workspaceDevDependencies: pkg.workspaceDevDependencies
-					},
-					currentVersion: pkg.version,
-					newVersion: result.newVersion,
-					bumpType: result.bumpType,
-					hasDirectChanges: pkg.commits.length > 0
-				});
 			}
-		} else {
-			const calculatedReleases = yield* versionCalculator.calculateBumps(packages, overrides);
-			releases.push(...calculatedReleases);
 		}
-		const releasesCount = releases.length;
-		yield* Console.log(`\n${releasesCount} package${releasesCount === 1 ? "" : "s"} will be released.`);
-		yield* git.branches.checkout(originalBranch);
-		yield* Console.log("Updating package.json files...");
-		yield* packageUpdater.applyReleases(packages, releases);
-		yield* Console.log("package.json files updated.");
-		yield* Console.log("Generating changelogs...");
-		const changelogFiles = [];
-		for (const release of releases) {
-			const pkg = packages.find((p) => p.name === release.package.name);
-			if (!pkg || !pkg.commits) continue;
-			const result = yield* changelog.generateChangelog(pkg, release.newVersion, pkg.commits);
-			yield* Effect.tryPromise({
-				try: async () => {
-					await (await import("node:fs/promises")).writeFile(result.filePath, result.markdown, "utf-8");
-				},
-				catch: (e) => /* @__PURE__ */ new Error(`Failed to write changelog: ${String(e)}`)
-			});
-			changelogFiles.push(result.filePath);
+		if (shouldRemoveOverrides) {
+			logger.info("Removing obsolete version overrides file...");
+			try {
+				await rm(overridesPath);
+				logger.success("Successfully removed obsolete version overrides file.");
+			} catch (e) {
+				logger.error("Failed to remove obsolete version overrides file:", e);
+			}
 		}
-		yield* Console.log(`Generated ${changelogFiles.length} changelog file${changelogFiles.length === 1 ? "" : "s"}.`);
-		const filesToStage = [...releases.map((r) => `${r.package.path}/package.json`), ...changelogFiles];
-		yield* Console.log(`Staging ${filesToStage.length} file${filesToStage.length === 1 ? "" : "s"}...`);
-		yield* git.commits.stage(filesToStage);
-		const commitMessage = `chore(release): prepare release
-
-${releasesCount} package${releasesCount === 1 ? "" : "s"} updated:
-${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
-		yield* Console.log("Creating commit...");
-		yield* git.commits.write(commitMessage);
-		yield* Console.log("Commit created.");
-		yield* Console.log(`Pushing to "${config.branch.release}"...`);
-		if (isNewRelease && !branchExists) yield* git.commits.push(config.branch.release);
-		else yield* git.commits.forcePush(config.branch.release);
-		yield* Console.log(`Push complete.`);
-		const prBody = yield* github.generateReleasePRBody(releases.map((r) => ({
-			packageName: r.package.name,
-			version: r.newVersion,
-			previousVersion: r.package.version
-		})));
-		if (isNewRelease) {
-			yield* Console.log("Creating release pull request...");
-			releasePullRequest = yield* github.createPullRequest({
-				title: config.pullRequest.title,
-				body: prBody,
-				head: config.branch.release,
-				base: config.branch.default,
-				draft: true
+	}
+	if (allUpdates.filter((u) => u.hasDirectChanges).length === 0) logger.warn("No packages have changes requiring a release");
+	logger.section("🔄 Version Updates");
+	logger.item(`Updating ${allUpdates.length} packages (including dependents)`);
+	for (const update of allUpdates) logger.item(`${update.package.name}: ${update.currentVersion} → ${update.newVersion}`);
+	await applyUpdates();
+	if (options.changelog?.enabled) {
+		logger.step("Updating changelogs");
+		const groupedPackageCommits = await versioningOps.getWorkspacePackageGroupedCommits(options.workspaceRoot, workspacePackages);
+		if (!groupedPackageCommits.ok) exitWithError(groupedPackageCommits.error.message);
+		const globalCommitsPerPackage = await versioningOps.getGlobalCommitsPerPackage(options.workspaceRoot, groupedPackageCommits.value, workspacePackages, options.globalCommitMode === "none" ? false : options.globalCommitMode);
+		if (!globalCommitsPerPackage.ok) exitWithError(globalCommitsPerPackage.error.message);
+		const changelogPromises = allUpdates.map((update) => {
+			const pkgCommits = groupedPackageCommits.value.get(update.package.name) || [];
+			const globalCommits = globalCommitsPerPackage.value.get(update.package.name) || [];
+			const allCommits = [...pkgCommits, ...globalCommits];
+			if (allCommits.length === 0) {
+				logger.verbose(`No commits for ${update.package.name}, skipping changelog`);
+				return Promise.resolve();
+			}
+			logger.verbose(`Updating changelog for ${farver.cyan(update.package.name)}`);
+			return updateChangelog({
+				normalizedOptions: {
+					...options,
+					workspaceRoot: options.workspaceRoot
+				},
+				githubClient: createGitHubClient({
+					owner: options.owner,
+					repo: options.repo,
+					githubToken: options.githubToken
+				}),
+				workspacePackage: update.package,
+				version: update.newVersion,
+				previousVersion: update.currentVersion !== "0.0.0" ? update.currentVersion : void 0,
+				commits: allCommits,
+				date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
 			});
-			yield* Console.log(`Release pull request #${releasePullRequest.number} created.`);
-		} else {
-			yield* Console.log("Updating pull request...");
-			yield* github.updatePullRequest(releasePullRequest.number, { body: prBody });
-			yield* Console.log("Pull request updated.");
-		}
-		yield* Console.log(`\nRelease preparation complete! View PR: #${releasePullRequest.number}`);
-		if (startingBranch !== (yield* git.branches.get)) {
-			yield* git.branches.checkout(startingBranch);
-			yield* Console.log(`Switched back to "${startingBranch}".`);
+		}).filter((p) => p != null);
+		const updates = await Promise.all(changelogPromises);
+		logger.success(`Updated ${updates.length} changelog(s)`);
+	}
+	const hasChangesToPush = await syncReleaseChanges({
+		git: gitOps,
+		workspaceRoot: options.workspaceRoot,
+		releaseBranch: options.branch.release,
+		commitMessage: "chore: update release versions",
+		hasChanges: true
+	});
+	if (!hasChangesToPush.ok) exitWithError(hasChangesToPush.error.message);
+	if (!hasChangesToPush.value) {
+		const prResult = await syncPullRequest({
+			github: githubOps,
+			releaseBranch: options.branch.release,
+			defaultBranch: options.branch.default,
+			pullRequestTitle: options.pullRequest?.title,
+			pullRequestBody: options.pullRequest?.body,
+			updates: allUpdates
+		});
+		if (!prResult.ok) exitWithError(prResult.error.message);
+		if (prResult.value.pullRequest) {
+			logger.item("No updates needed, PR is already up to date");
+			return {
+				updates: allUpdates,
+				prUrl: prResult.value.pullRequest.html_url,
+				created: prResult.value.created
+			};
 		}
+		logger.error("No changes to commit, and no existing PR. Nothing to do.");
+		return null;
+	}
+	const prResult = await syncPullRequest({
+		github: githubOps,
+		releaseBranch: options.branch.release,
+		defaultBranch: options.branch.default,
+		pullRequestTitle: options.pullRequest?.title,
+		pullRequestBody: options.pullRequest?.body,
+		updates: allUpdates
 	});
+	if (!prResult.ok) exitWithError(prResult.error.message);
+	if (prResult.value.pullRequest?.html_url) {
+		logger.section("🚀 Pull Request");
+		logger.success(`Pull request ${prResult.value.created ? "created" : "updated"}: ${prResult.value.pullRequest.html_url}`);
+	}
+	return {
+		updates: allUpdates,
+		prUrl: prResult.value.pullRequest?.html_url,
+		created: prResult.value.created
+	};
+}
+
+//#endregion
+//#region src/prepare.ts
+async function release(options) {
+	return prepareWorkflow(options);
+}
+
+//#endregion
+//#region src/workflows/publish.ts
+async function publishWorkflow(options) {
+	logger.warn("Publish workflow is not implemented yet.");
+	logger.verbose("Publish options:", options);
 }
 
 //#endregion
 //#region src/publish.ts
-function isPrerelease(version) {
-	const parsed = semver.parse(version);
-	return parsed !== null && parsed.prerelease.length > 0;
-}
-function getDistTag(version) {
-	return isPrerelease(version) ? "next" : "latest";
-}
-function buildPackage(packagePath) {
-	return Effect.gen(function* () {
-		const executor = yield* CommandExecutor.CommandExecutor;
-		const command = Command.make("pnpm", "run", "build").pipe(Command.workingDirectory(packagePath));
-		return (yield* executor.string(command).pipe(Effect.mapError((err) => /* @__PURE__ */ new Error(`Failed to build package at ${packagePath}: ${err.message}`)))).trim();
-	});
+async function publish(options) {
+	return publishWorkflow(options);
 }
-function constructPublishProgram(config) {
-	return Effect.gen(function* () {
-		const git = yield* GitService;
-		const npm = yield* NPMService;
-		const workspace = yield* WorkspaceService;
-		const dependencyGraph = yield* DependencyGraphService;
-		yield* git.workspace.assertWorkspaceReady;
-		const currentBranch = yield* git.branches.get;
-		if (currentBranch !== config.branch.default) return yield* Effect.fail(/* @__PURE__ */ new Error(`Publish must be run on the default branch "${config.branch.default}". Current branch: "${currentBranch}"`));
-		yield* Console.log(`On default branch "${config.branch.default}".`);
-		const publicPackages = (yield* workspace.discoverWorkspacePackages).filter((pkg) => !pkg.packageJson.private);
-		yield* Console.log(`Found ${publicPackages.length} public package${publicPackages.length === 1 ? "" : "s"} to check.`);
-		const orderedPackages = yield* dependencyGraph.topologicalOrder(publicPackages);
-		const results = [];
-		for (const updateOrder of orderedPackages) {
-			const pkg = updateOrder.package;
-			const version = pkg.version;
-			const tagName = `${pkg.name}@${version}`;
-			if (yield* npm.versionExists(pkg.name, version)) {
-				yield* Console.log(`Skipping ${pkg.name}@${version} - already published.`);
-				results.push({
-					packageName: pkg.name,
-					version,
-					status: "skipped",
-					reason: "Already published to npm"
-				});
-				continue;
-			}
-			yield* Console.log(`Building ${pkg.name}...`);
-			yield* buildPackage(pkg.path);
-			yield* Console.log(`Build complete for ${pkg.name}.`);
-			const distTag = getDistTag(version);
-			yield* Console.log(`Publishing ${pkg.name}@${version} with tag "${distTag}"...`);
-			const publishResult = yield* npm.publish({
-				packagePath: pkg.path,
-				tagName: distTag,
-				otp: config.npm.otp,
-				provenance: config.npm.provenance,
-				dryRun: config.dryRun
-			}).pipe(Effect.map(() => ({ success: true })), Effect.catchAll((err) => Effect.succeed({
-				success: false,
-				error: err
-			})));
-			if (publishResult.success) {
-				yield* Console.log(`Published ${pkg.name}@${version}.`);
-				if (!config.dryRun) {
-					yield* Console.log(`Creating tag ${tagName}...`);
-					yield* git.tags.create(tagName, `Release ${tagName}`);
-					yield* git.tags.push(tagName);
-					yield* Console.log(`Tag ${tagName} created and pushed.`);
-				} else yield* Console.log(`[Dry Run] Would create and push tag ${tagName}.`);
-				results.push({
-					packageName: pkg.name,
-					version,
-					status: "published"
-				});
-			} else {
-				const error = publishResult.error;
-				yield* Console.log(`Failed to publish ${pkg.name}@${version}: ${error.message}`);
-				results.push({
-					packageName: pkg.name,
-					version,
-					status: "failed",
-					reason: error.message
-				});
-			}
-		}
-		const published = results.filter((r) => r.status === "published");
-		const skipped = results.filter((r) => r.status === "skipped");
-		const failed = results.filter((r) => r.status === "failed");
-		yield* Console.log("\nPublish Summary:");
-		yield* Console.log(`   Published: ${published.length}`);
-		yield* Console.log(`   Skipped: ${skipped.length}`);
-		yield* Console.log(`   Failed: ${failed.length}`);
-		if (failed.length > 0) {
-			yield* Console.log("\nFailed packages:");
-			for (const f of failed) yield* Console.log(`   - ${f.packageName}@${f.version}: ${f.reason}`);
-			return yield* Effect.fail(/* @__PURE__ */ new Error("Some packages failed to publish."));
-		}
-		if (published.length === 0 && skipped.length > 0) yield* Console.log("\nAll packages were already published.");
-		else if (published.length > 0) yield* Console.log("\nPublish complete!");
-	});
+
+//#endregion
+//#region src/operations/discover.ts
+async function discoverPackages({ workspace, workspaceRoot, options }) {
+	return workspace.discoverWorkspacePackages(workspaceRoot, options);
 }
 
 //#endregion
-//#region src/verify.ts
-function satisfiesRange(range, version) {
-	return semver.satisfies(version, range, { includePrerelease: true });
-}
-function snapshotPackageJson(pkg, ref) {
-	return Effect.gen(function* () {
-		return yield* (yield* GitService).workspace.readFile(`${pkg.path}/package.json`, ref).pipe(Effect.flatMap((content) => Effect.try({
-			try: () => JSON.parse(content),
-			catch: (e) => /* @__PURE__ */ new Error(`Failed to parse package.json for ${pkg.name} at ${ref}: ${String(e)}`)
-		})));
+//#region src/workflows/verify.ts
+async function verifyWorkflow(options) {
+	const gitOps = createGitOperations();
+	const githubOps = createGitHubOperations({
+		owner: options.owner,
+		repo: options.repo,
+		githubToken: options.githubToken
 	});
-}
-function findDrift(packages, releases, branchSnapshots) {
-	const releaseVersionByName = /* @__PURE__ */ new Map();
-	for (const rel of releases) releaseVersionByName.set(rel.package.name, rel.newVersion);
-	const reasons = [];
-	for (const pkg of packages) {
-		const snapshot = branchSnapshots.get(pkg.name);
-		if (snapshot == null) {
-			reasons.push({
-				packageName: pkg.name,
-				reason: "package.json missing on release branch"
-			});
-			continue;
+	const workspaceOps = createWorkspaceOperations();
+	if (options.safeguards) {
+		const clean = await gitOps.isWorkingDirectoryClean(options.workspaceRoot);
+		if (!clean.ok || !clean.value) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	}
+	const releaseBranch = options.branch.release;
+	const defaultBranch = options.branch.default;
+	const releasePr = await githubOps.getExistingPullRequest(releaseBranch);
+	if (!releasePr.ok) exitWithError(releasePr.error.message);
+	if (!releasePr.value || !releasePr.value.head) {
+		logger.warn(`No open release pull request found for branch "${releaseBranch}". Nothing to verify.`);
+		return;
+	}
+	logger.info(`Found release PR #${releasePr.value.number}. Verifying against default branch "${defaultBranch}"...`);
+	const originalBranch = await gitOps.getCurrentBranch(options.workspaceRoot);
+	if (!originalBranch.ok) exitWithError(originalBranch.error.message);
+	if (originalBranch.value !== defaultBranch) {
+		const checkout = await gitOps.checkoutBranch(defaultBranch, options.workspaceRoot);
+		if (!checkout.ok || !checkout.value) exitWithError(`Failed to checkout branch: ${defaultBranch}`);
+	}
+	let existingOverrides = {};
+	try {
+		const overridesContent = await gitOps.readFileFromGit(options.workspaceRoot, releasePr.value.head.sha, ucdjsReleaseOverridesPath);
+		if (overridesContent.ok && overridesContent.value) {
+			existingOverrides = JSON.parse(overridesContent.value);
+			logger.info("Found existing version overrides file on release branch.");
 		}
-		if (snapshot instanceof Error) {
-			reasons.push({
-				packageName: pkg.name,
-				reason: snapshot.message
-			});
-			continue;
+	} catch {
+		logger.info("No version overrides file found on release branch. Continuing...");
+	}
+	const discovered = await discoverPackages({
+		workspace: workspaceOps,
+		workspaceRoot: options.workspaceRoot,
+		options
+	});
+	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
+	const ensured = ensureHasPackages(discovered.value);
+	if (!ensured.ok) {
+		logger.warn(ensured.error.message);
+		return;
+	}
+	const mainPackages = ensured.value;
+	const updatesResult = await calculateUpdates({
+		versioning: createVersioningOperations(),
+		workspacePackages: mainPackages,
+		workspaceRoot: options.workspaceRoot,
+		showPrompt: false,
+		globalCommitMode: options.globalCommitMode === "none" ? false : options.globalCommitMode,
+		overrides: existingOverrides
+	});
+	if (!updatesResult.ok) exitWithError(updatesResult.error.message);
+	const expectedUpdates = updatesResult.value.allUpdates;
+	const expectedVersionMap = new Map(expectedUpdates.map((u) => [u.package.name, u.newVersion]));
+	const prVersionMap = /* @__PURE__ */ new Map();
+	for (const pkg of mainPackages) {
+		const pkgJsonPath = relative(options.workspaceRoot, join(pkg.path, "package.json"));
+		const pkgJsonContent = await gitOps.readFileFromGit(options.workspaceRoot, releasePr.value.head.sha, pkgJsonPath);
+		if (pkgJsonContent.ok && pkgJsonContent.value) {
+			const pkgJson = JSON.parse(pkgJsonContent.value);
+			prVersionMap.set(pkg.name, pkgJson.version);
 		}
-		const expectedVersion = releaseVersionByName.get(pkg.name) ?? pkg.version;
-		const branchVersion = typeof snapshot.version === "string" ? snapshot.version : void 0;
-		if (!branchVersion) {
-			reasons.push({
-				packageName: pkg.name,
-				reason: "package.json on release branch lacks version"
-			});
+	}
+	if (originalBranch.value !== defaultBranch) await gitOps.checkoutBranch(originalBranch.value, options.workspaceRoot);
+	let isOutOfSync = false;
+	for (const [pkgName, expectedVersion] of expectedVersionMap.entries()) {
+		const prVersion = prVersionMap.get(pkgName);
+		if (!prVersion) {
+			logger.warn(`Package "${pkgName}" found in default branch but not in release branch. Skipping.`);
 			continue;
 		}
-		if (branchVersion !== expectedVersion) reasons.push({
-			packageName: pkg.name,
-			reason: `version mismatch: expected ${expectedVersion}, found ${branchVersion}`
-		});
-		for (const section of [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies"
-		]) {
-			const deps = snapshot[section];
-			if (!deps || typeof deps !== "object") continue;
-			for (const [depName, range] of Object.entries(deps)) {
-				const bumpedVersion = releaseVersionByName.get(depName);
-				if (!bumpedVersion) continue;
-				if (typeof range !== "string") {
-					reasons.push({
-						packageName: pkg.name,
-						reason: `${section}.${depName} is not a string range`
-					});
-					continue;
-				}
-				if (!satisfiesRange(range, bumpedVersion)) reasons.push({
-					packageName: pkg.name,
-					reason: `${section}.${depName} does not include ${bumpedVersion}`
-				});
-			}
-		}
+		if (gt(expectedVersion, prVersion)) {
+			logger.error(`Package "${pkgName}" is out of sync. Expected version >= ${expectedVersion}, but PR has ${prVersion}.`);
+			isOutOfSync = true;
+		} else logger.success(`Package "${pkgName}" is up to date (PR version: ${prVersion}, Expected: ${expectedVersion})`);
 	}
-	return reasons;
-}
-function constructVerifyProgram(config) {
-	return Effect.gen(function* () {
-		const git = yield* GitService;
-		const github = yield* GitHubService;
-		const dependencyGraph = yield* DependencyGraphService;
-		const versionCalculator = yield* VersionCalculatorService;
-		const workspace = yield* WorkspaceService;
-		yield* git.workspace.assertWorkspaceReady;
-		const releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
-		if (!releasePullRequest || !releasePullRequest.head) return yield* Effect.fail(/* @__PURE__ */ new Error(`Release pull request for branch "${config.branch.release}" does not exist.`));
-		yield* Console.log(`Release pull request #${releasePullRequest.number} exists.`);
-		if ((yield* git.branches.get) !== config.branch.default) {
-			yield* git.branches.checkout(config.branch.default);
-			yield* Console.log(`Checked out to default branch "${config.branch.default}".`);
-		}
-		const overrides = yield* loadOverrides({
-			sha: releasePullRequest.head.sha,
-			overridesPath: ".github/ucdjs-release.overrides.json"
+	const statusContext = "ucdjs/release-verify";
+	if (isOutOfSync) {
+		await githubOps.setCommitStatus({
+			sha: releasePr.value.head.sha,
+			state: "failure",
+			context: statusContext,
+			description: "Release PR is out of sync with the default branch. Please re-run the release process."
 		});
-		yield* Console.log("Loaded overrides:", overrides);
-		const packages = yield* workspace.discoverWorkspacePackages.pipe(Effect.flatMap(mergePackageCommitsIntoPackages), Effect.flatMap((pkgs) => mergeCommitsAffectingGloballyIntoPackage(pkgs, config.globalCommitMode)));
-		yield* Console.log("Discovered packages with commits and global commits:", packages);
-		const releases = yield* versionCalculator.calculateBumps(packages, overrides);
-		const ordered = yield* dependencyGraph.topologicalOrder(packages);
-		yield* Console.log("Calculated releases:", releases);
-		yield* Console.log("Release order:", ordered);
-		const releaseHeadSha = releasePullRequest.head.sha;
-		const branchSnapshots = /* @__PURE__ */ new Map();
-		for (const pkg of packages) {
-			const snapshot = yield* snapshotPackageJson(pkg, releaseHeadSha).pipe(Effect.catchAll((err) => Effect.succeed(err instanceof Error ? err : new Error(String(err)))));
-			branchSnapshots.set(pkg.name, snapshot);
-		}
-		const drift = findDrift(packages, releases, branchSnapshots);
-		if (drift.length === 0) yield* Console.log("Release branch is in sync with expected releases.");
-		else yield* Console.log("Release branch is out of sync:", drift);
-		const status = drift.length === 0 ? {
+		logger.error("Verification failed. Commit status set to 'failure'.");
+	} else {
+		await githubOps.setCommitStatus({
+			sha: releasePr.value.head.sha,
 			state: "success",
-			description: "Release artifacts in sync",
-			context: "release/verify"
-		} : {
-			state: "failure",
-			description: "Release branch out of sync",
-			context: "release/verify"
-		};
-		yield* github.setCommitStatus(releaseHeadSha, status);
-		if (drift.length > 0) return yield* Effect.fail(/* @__PURE__ */ new Error("Release branch is out of sync."));
-	});
+			context: statusContext,
+			description: "Release PR is up to date.",
+			targetUrl: `https://github.com/${options.owner}/${options.repo}/pull/${releasePr.value.number}`
+		});
+		logger.success("Verification successful. Commit status set to 'success'.");
+	}
+}
+
+//#endregion
+//#region src/verify.ts
+async function verify(options) {
+	return verifyWorkflow(options);
 }
 
 //#endregion
 //#region src/index.ts
 async function createReleaseScripts(options) {
-	const config = normalizeReleaseScriptsOptions(options);
-	const AppLayer = Layer.mergeAll(ChangelogService.Default, GitService.Default, GitHubService.Default, DependencyGraphService.Default, NPMService.Default, PackageUpdaterService.Default, VersionCalculatorService.Default, VersionPromptService.Default, WorkspaceService.Default).pipe(Layer.provide(Layer.succeed(ReleaseScriptsOptions, config)), Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer));
-	const runProgram = (program) => {
-		const provided = program.pipe(Effect.provide(AppLayer));
-		return Effect.runPromise(provided);
-	};
-	const safeguardProgram = Effect.gen(function* () {
-		return yield* (yield* GitService).workspace.assertWorkspaceReady;
-	});
-	try {
-		await runProgram(safeguardProgram);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		await Effect.runPromise(Console.error(`❌ Initialization failed: ${message}`));
-		throw err;
-	}
+	const normalizedOptions = normalizeReleaseScriptsOptions(options);
 	return {
 		async verify() {
-			return runProgram(constructVerifyProgram(config));
+			return verify(normalizedOptions);
 		},
 		async prepare() {
-			return runProgram(constructPrepareProgram(config));
+			return release(normalizedOptions);
 		},
 		async publish() {
-			return runProgram(constructPublishProgram(config));
+			return publish(normalizedOptions);
 		},
 		packages: {
 			async list() {
-				return runProgram(Effect.gen(function* () {
-					return yield* (yield* WorkspaceService).discoverWorkspacePackages;
-				}));
+				return discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions);
 			},
 			async get(packageName) {
-				return runProgram(Effect.gen(function* () {
-					return (yield* (yield* WorkspaceService).findPackageByName(packageName)) || null;
-				}));
+				return (await discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions)).find((p) => p.name === packageName);
 			}
 		}
 	};