@ucdjs/release-scripts 0.1.0-beta.23 → 0.1.0-beta.25

package/dist/index.mjs

@@ -1,1766 +1,1504 @@
-import { t as Eta } from "./eta-j5TFRbI4.mjs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { t as Eta } from "./eta-BV8TCRDW.mjs";
+import { Console, Context, Data, Effect, Layer, Schema } from "effect";
+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 process from "node:process";
-import readline from "node:readline";
-import farver from "farver";
-import mri from "mri";
-import { exec } from "tinyexec";
-import { dedent } from "@luxass/utils";
-import { getCommits, groupByType } from "commit-parser";
-import prompts from "prompts";
-import { compare, gt } from "semver";
+import semver from "semver";
+import fs from "node:fs/promises";
 
-//#region src/publish.ts
-function publish(_options) {}
-
-//#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$1) => {
-		console.info(...args$1);
-	},
-	warn: (...args$1) => {
-		console.warn(`  ${farver.yellow("⚠")}`, ...args$1);
-	},
-	error: (...args$1) => {
-		console.error(`  ${farver.red("✖")}`, ...args$1);
-	},
-	verbose: (...args$1) => {
-		if (!isVerbose) return;
-		if (args$1.length === 0) {
-			console.log();
-			return;
-		}
-		if (args$1.length > 1 && typeof args$1[0] === "string") {
-			console.log(farver.dim(args$1[0]), ...args$1.slice(1));
-			return;
-		}
-		console.log(...args$1);
-	},
-	section: (title) => {
-		console.log();
-		console.log(`  ${farver.bold(title)}`);
-		console.log(`  ${farver.gray("─".repeat(title.length + 2))}`);
-	},
-	emptyLine: () => {
-		console.log();
-	},
-	item: (message, ...args$1) => {
-		console.log(`  ${message}`, ...args$1);
-	},
-	step: (message) => {
-		console.log(`  ${farver.blue("→")} ${message}`);
-	},
-	success: (message) => {
-		console.log(`  ${farver.green("✓")} ${message}`);
-	},
-	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$1, opts = {}) {
-	return exec(bin, args$1, {
-		throwOnError: true,
-		...opts,
-		nodeOptions: {
-			stdio: "inherit",
-			...opts.nodeOptions
-		}
-	});
-}
-async function dryRun(bin, args$1, opts) {
-	return logger.verbose(farver.blue(`[dryrun] ${bin} ${args$1.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/core/git.ts
+//#region src/utils/changelog-formatters.ts
+const eta$1 = new Eta();
 /**
-* 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
+* Pure function to parse commits into changelog entries
 */
-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 parseCommits(commits) {
+	return commits.filter((commit) => commit.isConventional).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
+		}))
+	}));
 }
 /**
-* 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
+* Pure function to group changelog entries by type
 */
-async function doesBranchExist(branch, workspaceRoot) {
-	try {
-		await run("git", [
-			"rev-parse",
-			"--verify",
-			branch
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Retrieves the default branch name from the remote repository.
-* Falls back to "main" if the default branch cannot be determined.
-* @returns {Promise<string>} A Promise resolving to the default branch name as a string.
-*/
-async function getDefaultBranch(workspaceRoot) {
-	try {
-		const match = (await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} })).stdout.trim().match(/^refs\/remotes\/origin\/(.+)$/);
-		if (match && match[1]) return match[1];
-		return "main";
-	} catch {
-		return "main";
-	}
-}
-/**
-* 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
-*/
-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;
-	}
-}
-/**
-* Retrieves the list of available branches in the repository.
-* @param {string} workspaceRoot - The root directory of the workspace
-* @returns {Promise<string[]>} A Promise resolving to an array of branch names
-*/
-async function getAvailableBranches(workspaceRoot) {
-	try {
-		return (await run("git", ["branch", "--list"], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} })).stdout.split("\n").map((line) => line.replace("*", "").trim()).filter((line) => line.length > 0);
-	} catch (err) {
-		logger.error("Error getting available branches:", err);
-		throw err;
-	}
-}
-/**
-* 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
-*/
-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`);
-	}
-}
-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$1 = [
-			"push",
-			"origin",
-			branch
-		];
-		if (options?.forceWithLease) {
-			args$1.push("--force-with-lease");
-			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
-		} else if (options?.force) {
-			args$1.push("--force");
-			logger.info(`Force pushing branch: ${farver.green(branch)}`);
-		} else logger.info(`Pushing branch: ${farver.green(branch)}`);
-		await runIfNotDry("git", args$1, { 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;
-	}
+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);
+	}
+	return groups;
 }
 /**
-* 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.
+* Changelog template for Eta rendering
 */
-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;
-	}
-}
+const CHANGELOG_TEMPLATE = `# <%= it.packageName %> v<%= it.version %>
 
-//#endregion
-//#region src/core/changelog.ts
-const globalAuthorCache = /* @__PURE__ */ new Map();
-const DEFAULT_CHANGELOG_TEMPLATE = dedent`
-  <% if (it.previousVersion) { -%>
-  ## [<%= it.version %>](<%= it.compareUrl %>) (<%= it.date %>)
-  <% } else { -%>
-  ## <%= it.version %> (<%= it.date %>)
-  <% } %>
+**Previous version**: \`<%= it.previousVersion %>\`
+**New version**: \`<%= it.version %>\`
 
-  <% it.groups.forEach((group) => { %>
-  <% if (group.commits.length > 0) { %>
+<% 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"
+}; %>
 
-  ### <%= group.title %>
-  <% group.commits.forEach((commit) => { %>
+<% for (const type of typeOrder) { %>
+<% const entries = groups.get(type); %>
+<% if (entries && entries.length > 0) { %>
+## <%= typeLabels[type] || type.charAt(0).toUpperCase() + type.slice(1) %>
 
-  * <%= commit.line %>
-  <% }); %>
+<% for (const entry of entries) { %>
+- <% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %><% if (entry.references.length > 0) { %> (<%= entry.references.map(r => "#" + r.value).join(", ") %>)<% } %> (\`<%= entry.shortHash %>\`)
+<% } %>
 
-  <% } %>
-  <% }); %>
-`;
-async function generateChangelogEntry(options) {
-	const { packageName, version, previousVersion, date, commits, owner, repo, groups, template, githubClient } = options;
-	const compareUrl = previousVersion ? `https://github.com/${owner}/${repo}/compare/${packageName}@${previousVersion}...${packageName}@${version}` : void 0;
-	const grouped = groupByType(commits, {
-		includeNonConventional: false,
-		mergeKeys: Object.fromEntries(groups.map((g) => [g.name, g.types]))
+<% } %>
+<% } %>
+
+<% for (const [type, entries] of groups) { %>
+<% if (!typeOrder.includes(type)) { %>
+## <%= type.charAt(0).toUpperCase() + type.slice(1) %>
+
+<% for (const entry of entries) { %>
+- <% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %> (\`<%= entry.shortHash %>\`)
+<% } %>
+
+<% } %>
+<% } %>
+<% } %>`;
+/**
+* Pure function to format changelog as markdown
+*/
+function formatChangelogMarkdown(changelog) {
+	const groups = groupByType(changelog.entries);
+	return eta$1.renderString(CHANGELOG_TEMPLATE, {
+		packageName: changelog.packageName,
+		version: changelog.version,
+		previousVersion: changelog.previousVersion,
+		entries: changelog.entries,
+		groupedEntries: groups
 	});
-	const commitAuthors = await resolveCommitAuthors(commits, githubClient);
-	const templateData = {
+}
+/**
+* Pure function to create a changelog object
+*/
+function createChangelog(packageName, version, previousVersion, commits) {
+	return {
 		packageName,
 		version,
 		previousVersion,
-		date,
-		compareUrl,
-		owner,
-		repo,
-		groups: groups.map((group) => {
-			const commitsInGroup = grouped.get(group.name) ?? [];
-			if (commitsInGroup.length > 0) logger.verbose(`Found ${commitsInGroup.length} commits for group "${group.name}".`);
-			const formattedCommits = commitsInGroup.map((commit) => ({ line: formatCommitLine({
-				commit,
-				owner,
-				repo,
-				authors: commitAuthors.get(commit.hash) ?? []
-			}) }));
-			return {
-				name: group.name,
-				title: group.title,
-				commits: formattedCommits
-			};
-		})
+		entries: parseCommits(commits)
 	};
-	const eta = new Eta();
-	const templateToUse = template || DEFAULT_CHANGELOG_TEMPLATE;
-	return eta.renderString(templateToUse, templateData).trim();
 }
-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,
-		groups: normalizedOptions.groups,
-		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 authorsToResolve = /* @__PURE__ */ new Set();
-	const commitAuthors = /* @__PURE__ */ new Map();
-	for (const commit of commits) {
-		const authorsForCommit = [];
-		commit.authors.forEach((author, idx) => {
-			if (!author.email || !author.name) return;
-			let info = globalAuthorCache.get(author.email);
-			if (!info) {
-				info = {
-					commits: [],
-					name: author.name,
-					email: author.email
+
+//#endregion
+//#region src/services/changelog.service.ts
+var ChangelogService = class extends Effect.Service()("@ucdjs/release-scripts/ChangelogService", {
+	effect: Effect.gen(function* () {
+		function generateChangelog(pkg, newVersion, commits) {
+			return Effect.gen(function* () {
+				const changelog = createChangelog(pkg.name, newVersion, pkg.version, commits);
+				return {
+					changelog,
+					markdown: formatChangelogMarkdown(changelog),
+					filePath: `${pkg.path}/CHANGELOG.md`
 				};
-				globalAuthorCache.set(author.email, info);
-			}
-			if (idx === 0) info.commits.push(commit.shortHash);
-			authorsForCommit.push(info);
-			if (!info.login) authorsToResolve.add(info);
-		});
-		commitAuthors.set(commit.hash, authorsForCommit);
-	}
-	await Promise.all(Array.from(authorsToResolve).map((info) => githubClient.resolveAuthorInfo(info)));
-	return commitAuthors;
-}
-function formatCommitLine({ commit, owner, repo, authors }) {
-	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
-	let line = `${commit.description}`;
-	const references = commit.references ?? [];
-	if (references.length > 0) logger.verbose("Located references in commit", references.length);
-	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) => {
-			if (author.login) return `[@${author.login}](https://github.com/${author.login})`;
-			return author.name;
-		}).join(", ");
-		line += ` (by ${authorList})`;
-	}
-	return line;
-}
-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;
+			});
 		}
-	}
-	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;
+		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);
 				}
-				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") {};
+
+//#endregion
+//#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"
+	},
+	fix: {
+		title: "🐞 Bug Fixes",
+		color: "red"
+	},
+	refactor: {
+		title: "🔧 Code Refactoring",
+		color: "blue"
+	},
+	perf: {
+		title: "🏎 Performance",
+		color: "orange"
+	},
+	docs: {
+		title: "📚 Documentation",
+		color: "purple"
+	},
+	style: {
+		title: "🎨 Styles",
+		color: "pink"
 	}
+};
+function normalizeReleaseScriptsOptions(options) {
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false, npm = {} } = 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').");
+	const [owner, repo] = fullRepo.split("/");
+	if (!owner || !repo) throw new Error(`Invalid repo format: "${fullRepo}". Expected format: "owner/repo" (e.g., "octocat/hello-world").`);
 	return {
-		packageName,
-		versions,
-		headerLineEnd
+		dryRun,
+		workspaceRoot,
+		githubToken: token,
+		owner,
+		repo,
+		packages: typeof packages === "object" && !Array.isArray(packages) ? {
+			exclude: packages.exclude ?? [],
+			include: packages.include ?? [],
+			excludePrivate: packages.excludePrivate ?? false
+		} : packages,
+		branch: {
+			release: branch.release ?? "release/next",
+			default: branch.default ?? "main"
+		},
+		globalCommitMode,
+		pullRequest: {
+			title: pullRequest.title ?? "chore: release new version",
+			body: pullRequest.body ?? DEFAULT_PR_BODY_TEMPLATE
+		},
+		changelog: {
+			enabled: changelog.enabled ?? true,
+			template: changelog.template ?? DEFAULT_CHANGELOG_TEMPLATE,
+			emojis: changelog.emojis ?? true
+		},
+		types: options.types ? {
+			...DEFAULT_TYPES,
+			...types
+		} : DEFAULT_TYPES,
+		npm: {
+			otp: npm.otp,
+			provenance: npm.provenance ?? true
+		}
 	};
 }
+var ReleaseScriptsOptions = class extends Context.Tag("@ucdjs/release-scripts/ReleaseScriptsOptions")() {};
 
 //#endregion
-//#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)"
-			}
+//#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;
 		});
-		if (!res.ok) {
-			const errorText = await res.text();
-			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
+		function doesBranchExist(branch) {
+			return listBranches.pipe(Effect.map((branches) => branches.includes(branch)));
 		}
-		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
+		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();
+		});
+		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 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}`]);
+		}
+		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()
+				})));
+			}));
+		}
+		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,
+				push: pushChanges,
+				forcePush: forcePushChanges,
+				get: getCommits,
+				filesChangesBetweenRefs
+			},
+			tags: {
+				mostRecentForPackage: getMostRecentPackageTag,
+				create: createTag,
+				push: pushTag
+			},
+			workspace: {
+				readFile,
+				isWithinRepository,
+				isWorkingDirectoryClean,
+				assertWorkspaceReady
+			}
 		};
-		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
+	}),
+	dependencies: [NodeCommandExecutor.layer]
+}) {};
+
+//#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
+			})));
+		}
+		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 %>\`
+<% } %>
+
+## Changes
+
+See individual package changelogs for details.
+`;
+		function generateReleasePRBody(releases) {
+			return Effect.gen(function* () {
+				return eta.renderString(prBodyTemplate, {
+					count: releases.length,
+					releases
+				});
+			});
+		}
+		return {
+			getPullRequestByBranch,
+			setCommitStatus,
+			updatePullRequest,
+			generateReleasePRBody
 		};
-		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)
+	}),
+	dependencies: []
+}) {};
+
+//#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();
 		});
-		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
+			fetchPackument,
+			versionExists,
+			getLatestVersion,
+			publish
 		};
-	}
-	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
+	}),
+	dependencies: []
+}) {};
+
+//#endregion
+//#region src/services/workspace.service.ts
+const DependencyObjectSchema = Schema.Record({
+	key: Schema.String,
+	value: Schema.String
+});
+const PackageJsonSchema = Schema.Struct({
+	name: Schema.String,
+	private: Schema.optional(Schema.Boolean),
+	version: Schema.optional(Schema.String),
+	dependencies: Schema.optional(DependencyObjectSchema),
+	devDependencies: Schema.optional(DependencyObjectSchema),
+	peerDependencies: Schema.optional(DependencyObjectSchema)
+});
+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.String,
+	private: Schema.Boolean,
+	dependencies: Schema.optional(DependencyObjectSchema),
+	devDependencies: Schema.optional(DependencyObjectSchema),
+	peerDependencies: Schema.optional(DependencyObjectSchema)
+}));
+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"
+			})))));
+		}
+		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 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;
 		});
-		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 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 pkg = {
+						name: rawProject.name,
+						version: rawProject.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)));
+			}));
+		}
+		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;
 		}
-		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 findPackageByName(packageName) {
+			return discoverWorkspacePackages.pipe(Effect.map((packages) => packages.find((pkg) => pkg.name === packageName) || null));
+		}
+		return {
+			readPackageJson,
+			writePackageJson,
+			findWorkspacePackages,
+			discoverWorkspacePackages,
+			findPackageByName
+		};
+	}),
+	dependencies: []
+}) {};
+
+//#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;
 		}
-		return info;
 	}
-};
-function createGitHubClient(options) {
-	return new GitHubClient(options);
+	return {
+		updated: changed,
+		next: changed ? next : record
+	};
 }
-const DEFAULT_PR_BODY_TEMPLATE = dedent`
-  This PR was automatically generated by the release script.
-
-  The following packages have been prepared for release:
-
-  <% it.packages.forEach((pkg) => { %>
-  - **<%= pkg.name %>**: <%= pkg.currentVersion %> → <%= pkg.newVersion %> (<%= pkg.bumpType %>)
-  <% }) %>
-
-  Please review the changes and merge when ready.
-
-  For a more in-depth look at the changes, please refer to the individual package changelogs.
+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]
+}) {};
 
-  > [!NOTE]
-  > When this PR is merged, the release process will be triggered automatically, publishing the new package versions to the registry.
-`;
-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();
+//#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) {
+	if (commit.isBreaking) return "major";
+	if (commit.type === "feat") return "minor";
+	if (commit.type === "fix" || commit.type === "perf") return "patch";
+	return "none";
 }
-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
-	})) });
+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/versioning/commits.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;
+//#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}`)));
+		}));
+	});
 }
 /**
-* Get commits grouped by workspace package.
-* For each package, retrieves all commits since its last release tag that affect that package.
+* 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.
+*
+* 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
+*
+* 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)
 *
-* @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
+* 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 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.)
+*
+* @returns A map of package names to their relevant global commits
 */
-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
+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: "."
 		});
-		logger.verbose(`Found ${farver.cyan(allCommits.length)} commits for package ${farver.bold(pkg.name)} since tag ${farver.cyan(lastTag ?? "N/A")}`);
-		return {
-			pkgName: pkg.name,
-			commits: allCommits
-		};
+		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);
+			}
+			result.set(pkg.name, globalCommits);
+		}
+		return yield* Effect.succeed(packages.map((pkg) => ({
+			...pkg,
+			globalCommits: result.get(pkg.name) || []
+		})));
 	});
-	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
+* 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
 */
-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;
+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;
+	});
 }
 /**
-* 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
+* Files that are considered dependency-related in a monorepo.
 */
-function isGlobalCommit(workspaceRoot, files, packagePaths) {
-	if (!files || files.length === 0) return false;
-	return !files.some((file) => fileMatchesPackageFolder(file, packagePaths, workspaceRoot));
-}
-const DEPENDENCY_FILES = [
+const DEPENDENCY_FILES = new Set([
 	"package.json",
 	"pnpm-lock.yaml",
-	"pnpm-workspace.yaml",
 	"yarn.lock",
-	"package-lock.json"
-];
+	"package-lock.json",
+	"pnpm-workspace.yaml"
+]);
 /**
-* 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
+* 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 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
-	};
+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}`));
 }
 /**
-* 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).
+* Finds the oldest and newest commits across all packages.
 *
-* Performance: Makes ONE batched git call to get files for all commits across all packages.
+* This establishes the overall time range we need to analyze for global commits.
 *
-* @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
+* @param packages - Array of packages with their commits
+* @returns Tuple of [oldestCommitSha, newestCommitSha], or [null, null] if no commits found
 */
-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);
-		}
-		logger.verbose("Package global commits found", `${farver.bold(pkgName)}: ${farver.cyan(globalCommitsAffectingPackage.length)} global commits`);
-		if (mode === "all") {
-			result.set(pkgName, globalCommitsAffectingPackage);
-			continue;
-		}
-		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);
-			}
-		}
-		logger.verbose("Global commits affect dependencies", `${farver.bold(pkgName)}: ${farver.cyan(dependencyCommits.length)} global commits affect dependencies`);
-		result.set(pkgName, dependencyCommits);
-	}
-	return result;
-}
-function determineBumpType(commit) {
-	if (commit.isBreaking) return "major";
-	if (!commit.isConventional || !commit.type) return "none";
-	switch (commit.type) {
-		case "feat": return "minor";
-		case "fix":
-		case "perf": return "patch";
-		case "docs":
-		case "style":
-		case "refactor":
-		case "test":
-		case "build":
-		case "ci":
-		case "chore":
-		case "revert": return "none";
-		default: return "none";
-	}
+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;
+	}
+	if (oldestCommit == null || newestCommit == null) return [null, null];
+	return [oldestCommit.hash, newestCommit.hash];
 }
 
 //#endregion
-//#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());
-	}
-	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);
+//#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 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.release) {
+			yield* git.branches.checkout(config.branch.release);
+			yield* Console.log(`✅ Checked out to release branch "${config.branch.release}".`);
 		}
-	}
-	return {
-		packages: packagesMap,
-		dependents
-	};
-}
-/**
-* Get all packages affected by changes (including transitive dependents)
-*
-* Uses graph traversal to find all packages that need updates:
-* - Packages with direct changes
-* - All packages that depend on changed packages (transitively)
-*
-* @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
-*
-* 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.
-*
-* @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 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;
+		yield* Console.log(`🔄 Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
+		yield* git.branches.rebase(config.branch.default);
+		yield* Console.log(`✅ Rebase complete.`);
+		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.`);
+		const releases = yield* versionCalculator.calculateBumps(packages, overrides);
+		yield* dependencyGraph.topologicalOrder(packages);
+		const releasesCount = releases.length;
+		yield* Console.log(`📊 ${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);
 		}
-		const pkg = workspacePackages.find((p) => p.name === pkgName);
-		if (!pkg) continue;
-		allUpdates.push(createVersionUpdate(pkg, "patch", false));
-	}
-	return allUpdates;
+		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(`⬆️  Force pushing to "${config.branch.release}"...`);
+		yield* git.commits.forcePush(config.branch.release);
+		yield* Console.log("✅ Force push complete.");
+		yield* Console.log("📄 Updating pull request...");
+		const prBody = yield* github.generateReleasePRBody(releases.map((r) => ({
+			packageName: r.package.name,
+			version: r.newVersion,
+			previousVersion: r.package.version
+		})));
+		yield* github.updatePullRequest(releasePullRequest.number, { body: prBody });
+		yield* Console.log("✅ Pull request updated.");
+		yield* Console.log(`\n🎉 Release preparation complete! View PR: #${releasePullRequest.number}`);
+	});
 }
 
 //#endregion
-//#region src/versioning/version.ts
-function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
-}
-function getNextVersion(currentVersion, bump) {
-	if (bump === "none") {
-		logger.verbose(`No version bump needed, keeping version ${currentVersion}`);
-		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 createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = getNextVersion(pkg.version, bump);
-	return {
-		package: pkg,
-		currentVersion: pkg.version,
-		newVersion,
-		bumpType: bump,
-		hasDirectChanges
-	};
+//#region src/publish.ts
+function isPrerelease(version) {
+	const parsed = semver.parse(version);
+	return parsed !== null && parsed.prerelease.length > 0;
 }
-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";
+function getDistTag(version) {
+	return isPrerelease(version) ? "next" : "latest";
 }
-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;
+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 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}.`);
+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
+				});
 			}
-			newVersion = selectedVersion;
 		}
-		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
-			});
+		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("\n📊 Publish 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("\n❌ Failed 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."));
 		}
-	}
-	return {
-		updates: versionUpdates,
-		overrides: newOverrides
-	};
-}
-/**
-* Calculate version updates and prepare dependent updates
-* Returns both the updates and a function to apply them
-*/
-async function calculateAndPrepareVersionUpdates({ workspacePackages, packageCommits, workspaceRoot, showPrompt, globalCommitsPerPackage, overrides }) {
-	const { updates: directUpdates, overrides: newOverrides } = await calculateVersionUpdates({
-		workspacePackages,
-		packageCommits,
-		workspaceRoot,
-		showPrompt,
-		globalCommitsPerPackage,
-		overrides
+		if (published.length === 0 && skipped.length > 0) yield* Console.log("\n✅ All packages were already published.");
+		else if (published.length > 0) yield* Console.log("\n🎉 Publish complete!");
 	});
-	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
-	};
-}
-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`);
-}
-/**
-* Get all dependency updates needed for a package
-*/
-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 (updates.size === 0) logger.verbose(`  - No dependency updates needed`);
-	return updates;
 }
 
 //#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
+//#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)}`)
+		})));
 	});
-	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"
+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;
+		}
+		if (snapshot instanceof Error) {
+			reasons.push({
+				packageName: pkg.name,
+				reason: snapshot.message
+			});
+			continue;
+		}
+		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"
+			});
+			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}`
+				});
 			}
-		],
-		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/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;
+	return reasons;
 }
-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);
-				})
-			};
+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 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/shared/options.ts
-const DEFAULT_COMMIT_GROUPS = [
-	{
-		name: "features",
-		title: "Features",
-		types: ["feat"]
-	},
-	{
-		name: "fixes",
-		title: "Bug Fixes",
-		types: ["fix", "perf"]
-	},
-	{
-		name: "refactor",
-		title: "Refactoring",
-		types: ["refactor"]
-	},
-	{
-		name: "docs",
-		title: "Documentation",
-		types: ["docs"]
-	}
-];
-function normalizeSharedOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, prompts: prompts$1 = {
-		packages: true,
-		versions: true
-	}, groups = DEFAULT_COMMIT_GROUPS } = options;
-	if (!githubToken.trim()) exitWithError("GitHub token is required", "Set GITHUB_TOKEN environment variable or pass it in options");
-	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
-	const [owner, repo] = fullRepo.split("/");
-	if (!owner || !repo) exitWithError(`Invalid repo format: "${fullRepo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
-	return {
-		packages: typeof packages === "object" && !Array.isArray(packages) ? {
-			exclude: packages.exclude ?? [],
-			include: packages.include ?? [],
-			excludePrivate: packages.excludePrivate ?? false
-		} : packages,
-		prompts: {
-			packages: prompts$1?.packages ?? true,
-			versions: prompts$1?.versions ?? true
-		},
-		workspaceRoot,
-		githubToken,
-		owner,
-		repo,
-		groups
-	};
-}
-async function normalizeReleaseOptions(options) {
-	const normalized = normalizeSharedOptions(options);
-	let defaultBranch = options.branch?.default?.trim();
-	const releaseBranch = options.branch?.release?.trim() ?? "release/next";
-	if (defaultBranch == null || defaultBranch === "") {
-		defaultBranch = await getDefaultBranch(normalized.workspaceRoot);
-		if (!defaultBranch) exitWithError("Could not determine default branch", "Please specify the default branch in options");
-	}
-	if (defaultBranch === releaseBranch) exitWithError(`Default branch and release branch cannot be the same: "${defaultBranch}"`, "Specify different branches for default and release");
-	const localBranchExists = await doesBranchExist(defaultBranch, normalized.workspaceRoot);
-	const remoteBranchExists = await doesBranchExist(`origin/${defaultBranch}`, normalized.workspaceRoot);
-	if (!localBranchExists && !remoteBranchExists) {
-		const availableBranches = await getAvailableBranches(normalized.workspaceRoot);
-		exitWithError(`Default branch "${defaultBranch}" does not exist in the repository`, `Couldn't find it locally or on the remote 'origin'.\nAvailable local branches: ${availableBranches.join(", ")}`);
-	}
-	logger.verbose(`Using default branch: ${farver.green(defaultBranch)}`);
-	return {
-		...normalized,
-		branch: {
-			release: releaseBranch,
-			default: defaultBranch
-		},
-		safeguards: options.safeguards ?? true,
-		globalCommitMode: options.globalCommitMode ?? "dependencies",
-		pullRequest: {
-			title: options.pullRequest?.title ?? "chore: release new version",
-			body: options.pullRequest?.body ?? DEFAULT_PR_BODY_TEMPLATE
-		},
-		changelog: {
-			enabled: options.changelog?.enabled ?? true,
-			template: options.changelog?.template ?? DEFAULT_CHANGELOG_TEMPLATE
+		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 ? {
+			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."));
+	});
 }
 
 //#endregion
-//#region src/release.ts
-async function release(options) {
-	const { workspaceRoot,...normalizedOptions } = await normalizeReleaseOptions(options);
-	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
-	const workspacePackages = await discoverWorkspacePackages(workspaceRoot, options);
-	if (workspacePackages.length === 0) {
-		logger.warn("No packages found to release");
-		return null;
-	}
-	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 groupedPackageCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
-	const globalCommitsPerPackage = await getGlobalCommitsPerPackage(workspaceRoot, groupedPackageCommits, workspacePackages, normalizedOptions.globalCommitMode);
-	const githubClient = createGitHubClient({
-		owner: normalizedOptions.owner,
-		repo: normalizedOptions.repo,
-		githubToken: normalizedOptions.githubToken
-	});
-	const prOps = await orchestrateReleasePullRequest({
-		workspaceRoot,
-		githubClient,
-		releaseBranch: normalizedOptions.branch.release,
-		defaultBranch: normalizedOptions.branch.default,
-		pullRequestTitle: options.pullRequest?.title,
-		pullRequestBody: options.pullRequest?.body
+//#region src/index.ts
+async function createReleaseScripts(options) {
+	const config = normalizeReleaseScriptsOptions(options);
+	const AppLayer = Layer.succeed(ReleaseScriptsOptions, config).pipe(Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer), Layer.provide(ChangelogService.Default), Layer.provide(GitService.Default), Layer.provide(GitHubService.Default), Layer.provide(DependencyGraphService.Default), Layer.provide(NPMService.Default), Layer.provide(PackageUpdaterService.Default), Layer.provide(VersionCalculatorService.Default), Layer.provide(WorkspaceService.Default));
+	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;
 	});
-	await prOps.prepareBranch();
-	const overridesPath = join(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 { allUpdates, applyUpdates, overrides: newOverrides } = await calculateAndPrepareVersionUpdates({
-		workspacePackages,
-		packageCommits: groupedPackageCommits,
-		workspaceRoot,
-		showPrompt: options.prompts?.versions !== false,
-		globalCommitsPerPackage,
-		overrides: existingOverrides
-	});
-	if (Object.keys(newOverrides).length > 0) {
-		logger.info("Writing version overrides file...");
-		try {
-			await mkdir(join(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);
-		}
-	}
-	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;
-				}
-			}
-		}
-		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);
-			}
-		}
-	}
-	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 (normalizedOptions.changelog.enabled) {
-		logger.step("Updating changelogs");
-		const changelogPromises = allUpdates.map((update) => {
-			const pkgCommits = groupedPackageCommits.get(update.package.name) || [];
-			const globalCommits = globalCommitsPerPackage.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: {
-					...normalizedOptions,
-					workspaceRoot
-				},
-				githubClient,
-				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]
-			});
-		}).filter((p) => p != null);
-		const updates = await Promise.all(changelogPromises);
-		logger.success(`Updated ${updates.length} changelog(s)`);
-	}
-	if (!await prOps.syncChanges(true)) if (prOps.doesReleasePRExist && prOps.existingPullRequest) {
-		logger.item("No updates needed, PR is already up to date");
-		const { pullRequest: pullRequest$1, created: created$1 } = await prOps.syncPullRequest(allUpdates);
-		await prOps.cleanup();
-		return {
-			updates: allUpdates,
-			prUrl: pullRequest$1?.html_url,
-			created: created$1
-		};
-	} else {
-		logger.error("No changes to commit, and no existing PR. Nothing to do.");
-		return null;
-	}
-	const { pullRequest, created } = await prOps.syncPullRequest(allUpdates);
-	await prOps.cleanup();
-	if (pullRequest?.html_url) {
-		logger.section("🚀 Pull Request");
-		logger.success(`Pull request ${created ? "created" : "updated"}: ${pullRequest.html_url}`);
+		await runProgram(safeguardProgram);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		await Effect.runPromise(Console.error(`❌ Initialization failed: ${message}`));
+		throw err;
 	}
 	return {
-		updates: allUpdates,
-		prUrl: pullRequest?.html_url,
-		created
-	};
-}
-async function orchestrateReleasePullRequest({ workspaceRoot, githubClient, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody }) {
-	const currentBranch = await getCurrentBranch(workspaceRoot);
-	if (currentBranch !== defaultBranch) exitWithError(`Current branch is '${currentBranch}'. Please switch to the default branch '${defaultBranch}' before proceeding.`, `git checkout ${defaultBranch}`);
-	const existingPullRequest = await githubClient.getExistingPullRequest(releaseBranch);
-	const doesReleasePRExist = !!existingPullRequest;
-	if (doesReleasePRExist) logger.item("Found existing release pull request");
-	else logger.item("Will create new pull request");
-	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
-	return {
-		existingPullRequest,
-		doesReleasePRExist,
-		async prepareBranch() {
-			if (!branchExists) await createBranch(releaseBranch, defaultBranch, workspaceRoot);
-			logger.step(`Checking out release branch: ${releaseBranch}`);
-			if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
-			if (branchExists) {
-				logger.step("Pulling latest changes from remote");
-				if (!await pullLatestChanges(releaseBranch, workspaceRoot)) logger.warn("Failed to pull latest changes, continuing anyway");
-			}
-			logger.step(`Rebasing onto ${defaultBranch}`);
-			if (!await rebaseBranch(defaultBranch, workspaceRoot)) throw new Error(`Failed to rebase onto ${defaultBranch}. Please resolve conflicts manually.`);
+		async verify() {
+			return runProgram(constructVerifyProgram(config));
 		},
-		async syncChanges(hasChanges) {
-			const hasCommitted = hasChanges ? await commitChanges("chore: update release versions", workspaceRoot) : false;
-			const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
-			if (!hasCommitted && !isBranchAhead) {
-				logger.item("No changes to commit and branch is in sync with remote");
-				return false;
-			}
-			logger.step("Pushing changes to remote");
-			if (!await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true })) throw new Error(`Failed to push changes to ${releaseBranch}. Remote may have been updated.`);
-			return true;
+		async prepare() {
+			return runProgram(constructPrepareProgram(config));
 		},
-		async syncPullRequest(updates) {
-			const prTitle = existingPullRequest?.title || pullRequestTitle || "chore: update package versions";
-			const prBody = generatePullRequestBody(updates, pullRequestBody);
-			const pullRequest = await githubClient.upsertPullRequest({
-				pullNumber: existingPullRequest?.number,
-				title: prTitle,
-				body: prBody,
-				head: releaseBranch,
-				base: defaultBranch
-			});
-			logger.success(`${doesReleasePRExist ? "Updated" : "Created"} pull request: ${pullRequest?.html_url}`);
-			return {
-				pullRequest,
-				created: !doesReleasePRExist
-			};
+		async publish() {
+			return runProgram(constructPublishProgram(config));
 		},
-		async cleanup() {
-			await checkoutBranch(defaultBranch, workspaceRoot);
+		packages: {
+			async list() {
+				return runProgram(Effect.gen(function* () {
+					return yield* (yield* WorkspaceService).discoverWorkspacePackages;
+				}));
+			},
+			async get(packageName) {
+				return runProgram(Effect.gen(function* () {
+					return (yield* (yield* WorkspaceService).findPackageByName(packageName)) || null;
+				}));
+			}
 		}
 	};
 }
 
 //#endregion
-//#region src/verify.ts
-async function verify(options) {
-	const { workspaceRoot,...normalizedOptions } = await normalizeReleaseOptions(options);
-	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
-	const githubClient = createGitHubClient({
-		owner: normalizedOptions.owner,
-		repo: normalizedOptions.repo,
-		githubToken: normalizedOptions.githubToken
-	});
-	const releaseBranch = normalizedOptions.branch.release;
-	const defaultBranch = normalizedOptions.branch.default;
-	const releasePr = await githubClient.getExistingPullRequest(releaseBranch);
-	if (!releasePr || !releasePr.head) {
-		logger.warn(`No open release pull request found for branch "${releaseBranch}". Nothing to verify.`);
-		return;
-	}
-	logger.info(`Found release PR #${releasePr.number}. Verifying against default branch "${defaultBranch}"...`);
-	const originalBranch = await getCurrentBranch(workspaceRoot);
-	if (originalBranch !== defaultBranch) await checkoutBranch(defaultBranch, workspaceRoot);
-	const overridesPath = ucdjsReleaseOverridesPath;
-	let existingOverrides = {};
-	try {
-		const overridesContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, overridesPath);
-		if (overridesContent) {
-			existingOverrides = JSON.parse(overridesContent);
-			logger.info("Found existing version overrides file on release branch.");
-		}
-	} catch {
-		logger.info("No version overrides file found on release branch. Continuing...");
-	}
-	const mainPackages = await discoverWorkspacePackages(workspaceRoot, options);
-	const mainCommits = await getWorkspacePackageGroupedCommits(workspaceRoot, mainPackages);
-	const { allUpdates: expectedUpdates } = await calculateAndPrepareVersionUpdates({
-		workspacePackages: mainPackages,
-		packageCommits: mainCommits,
-		workspaceRoot,
-		showPrompt: false,
-		globalCommitsPerPackage: await getGlobalCommitsPerPackage(workspaceRoot, mainCommits, mainPackages, normalizedOptions.globalCommitMode),
-		overrides: existingOverrides
-	});
-	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(workspaceRoot, join(pkg.path, "package.json"));
-		const pkgJsonContent = await readFileFromGit(workspaceRoot, releasePr.head.sha, pkgJsonPath);
-		if (pkgJsonContent) {
-			const pkgJson = JSON.parse(pkgJsonContent);
-			prVersionMap.set(pkg.name, pkgJson.version);
-		}
-	}
-	if (originalBranch !== defaultBranch) await checkoutBranch(originalBranch, 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 (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})`);
-	}
-	const statusContext = "ucdjs/release-verify";
-	if (isOutOfSync) {
-		await githubClient.setCommitStatus({
-			sha: releasePr.head.sha,
-			state: "failure",
-			context: statusContext,
-			description: "Release PR is out of sync with the default branch. Please re-run the release process."
-		});
-		logger.error("Verification failed. Commit status set to 'failure'.");
-	} else {
-		await githubClient.setCommitStatus({
-			sha: releasePr.head.sha,
-			state: "success",
-			context: statusContext,
-			description: "Release PR is up to date.",
-			targetUrl: `https://github.com/${normalizedOptions.owner}/${normalizedOptions.repo}/pull/${releasePr.number}`
-		});
-		logger.success("Verification successful. Commit status set to 'success'.");
-	}
-}
-
-//#endregion
-export { publish, release, verify };
+export { createReleaseScripts };