@ucdjs/release-scripts 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/index.mjs

@@ -1,835 +1,1544 @@
+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 { getCommits } from "commit-parser";
-import createDebug from "debug";
-import farver from "farver";
-import { exec } from "tinyexec";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import prompts from "prompts";
+import semver from "semver";
+import fs from "node:fs/promises";
 
-//#region src/logger.ts
-function createDebugger(namespace) {
-	const debug$2 = createDebug(namespace);
-	if (debug$2.enabled) return debug$2;
-}
-
-//#endregion
-//#region src/utils.ts
-const globalOptions = { dryRun: false };
-async function run(bin, args, opts = {}) {
-	return exec(bin, args, {
-		throwOnError: true,
-		...opts,
-		nodeOptions: {
-			stdio: "inherit",
-			...opts.nodeOptions
-		}
-	});
-}
-async function dryRun(bin, args, opts) {
-	return console.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
-}
-const runIfNotDry = globalOptions.dryRun ? dryRun : run;
-
-//#endregion
-//#region src/commits.ts
-const debug$1 = createDebugger("ucdjs:release-scripts:commits");
-async function getLastPackageTag(packageName, workspaceRoot) {
-	const { stdout } = await run("git", ["tag", "--list"], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} });
-	return stdout.split("\n").map((tag) => tag.trim()).filter(Boolean).reverse().find((tag) => tag.startsWith(`${packageName}@`));
-}
-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;
-}
-async function getPackageCommits(pkg, workspaceRoot) {
-	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
-	const allCommits = getCommits({
-		from: lastTag,
-		to: "HEAD"
-	});
-	debug$1?.(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
-	const touchedCommitHashes = await getCommitsTouchingPackage(lastTag || "HEAD", "HEAD", pkg.path, workspaceRoot);
-	const touchedSet = new Set(touchedCommitHashes);
-	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit.shortHash));
-	debug$1?.(`${packageCommits.length} commits affect ${pkg.name}`);
-	return packageCommits;
-}
-async function analyzePackageCommits(pkg, workspaceRoot) {
-	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
-}
-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";
-	}
-}
-async function getCommitsTouchingPackage(from, to, packagePath, workspaceRoot) {
-	try {
-		const { stdout } = await run("git", [
-			"log",
-			"--pretty=format:%h",
-			from === "HEAD" ? "HEAD" : `${from}...${to}`,
-			"--",
-			packagePath
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-	} catch (error) {
-		debug$1?.(`Error getting commits touching package: ${error}`);
-		return [];
-	}
-}
-
-//#endregion
-//#region src/validation.ts
+//#region src/utils/changelog-formatters.ts
+const eta$1 = new Eta();
 /**
-* Validation utilities for release scripts
+* Pure function to parse commits into changelog entries
 */
-function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
-}
-function validateSemver(version) {
-	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
+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
+		}))
+	}));
 }
-
-//#endregion
-//#region src/version.ts
 /**
-* Calculate the new version based on current version and bump type
-* Pure function - no side effects, easily testable
+* Pure function to group changelog entries by type
 */
-function calculateNewVersion(currentVersion, bump) {
-	if (bump === "none") return currentVersion;
-	validateSemver(currentVersion);
-	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
-	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
-	const [, major, minor, patch, suffix] = 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;
+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 `${newMajor}.${newMinor}.${newPatch}`;
+	return groups;
 }
 /**
-* Create a version update object
+* Changelog template for Eta rendering
 */
-function createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = calculateNewVersion(pkg.version, bump);
-	return {
-		package: pkg,
-		currentVersion: pkg.version,
-		newVersion,
-		bumpType: bump,
-		hasDirectChanges
-	};
-}
+const CHANGELOG_TEMPLATE = `# <%= it.packageName %> v<%= it.version %>
+
+**Previous version**: \`<%= it.previousVersion %>\`
+**New version**: \`<%= it.version %>\`
+
+<% if (it.entries.length === 0) { %>
+*No conventional commits found.*
+<% } else { %>
+<% const groups = it.groupedEntries; %>
+<% const typeOrder = ["breaking", "feat", "fix", "perf", "docs", "style", "refactor", "test", "build", "ci", "chore"]; %>
+<% const typeLabels = {
+  breaking: "💥 Breaking Changes",
+  feat: "✨ Features",
+  fix: "🐛 Bug Fixes",
+  perf: "⚡ Performance",
+  docs: "📝 Documentation",
+  style: "💄 Styling",
+  refactor: "♻️ Refactoring",
+  test: "✅ Tests",
+  build: "📦 Build",
+  ci: "👷 CI",
+  chore: "🔧 Chores"
+}; %>
+
+<% for (const type of typeOrder) { %>
+<% const entries = groups.get(type); %>
+<% if (entries && entries.length > 0) { %>
+## <%= typeLabels[type] || type.charAt(0).toUpperCase() + type.slice(1) %>
+
+<% 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 %>\`)
+<% } %>
+
+<% } %>
+<% } %>
+
+<% 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 %>\`)
+<% } %>
+
+<% } %>
+<% } %>
+<% } %>`;
 /**
-* Update a package.json file with new version and dependency versions
+* Pure function to format changelog as markdown
 */
-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;
-	for (const [depName, depVersion] of dependencyUpdates) {
-		if (packageJson.dependencies?.[depName]) {
-			if (packageJson.dependencies[depName] === "workspace:*") continue;
-			packageJson.dependencies[depName] = `^${depVersion}`;
-		}
-		if (packageJson.devDependencies?.[depName]) {
-			if (packageJson.devDependencies[depName] === "workspace:*") continue;
-			packageJson.devDependencies[depName] = `^${depVersion}`;
-		}
-		if (packageJson.peerDependencies?.[depName]) {
-			if (packageJson.peerDependencies[depName] === "workspace:*") continue;
-			packageJson.peerDependencies[depName] = `^${depVersion}`;
-		}
-	}
-	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+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
+	});
 }
 /**
-* Get all dependency updates needed for a package
+* Pure function to create a changelog object
 */
-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) updates.set(dep, update.newVersion);
-	}
-	return updates;
+function createChangelog(packageName, version, previousVersion, commits) {
+	return {
+		packageName,
+		version,
+		previousVersion,
+		entries: parseCommits(commits)
+	};
 }
 
 //#endregion
-//#region src/dependencies.ts
-/**
-* Pure function: Determine which packages need updates due to 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.
-*
-* @param updateOrder - Packages in topological order with their dependency levels
-* @param directUpdates - Packages with direct code changes
-* @returns All updates including dependent packages
-*/
-function createDependentUpdates(updateOrder, directUpdates) {
-	const allUpdates = [...directUpdates];
-	const updatedPackages = new Set(directUpdates.map((u) => u.package.name));
-	for (const { package: pkg } of updateOrder) {
-		if (updatedPackages.has(pkg.name)) continue;
-		if (hasUpdatedDependencies(pkg, updatedPackages)) {
-			allUpdates.push(createVersionUpdate(pkg, "patch", false));
-			updatedPackages.add(pkg.name);
+//#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`
+				};
+			});
+		}
+		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);
+				}
+			}
+			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"
 	}
-	return allUpdates;
-}
-/**
-* Pure function: Check if a package has any updated dependencies
-*/
-function hasUpdatedDependencies(pkg, updatedPackages) {
-	return [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies].some((dep) => updatedPackages.has(dep));
+};
+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 {
+		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/git.ts
-/**
-* 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
-*/
-async function isWorkingDirectoryClean(workspaceRoot) {
-	try {
-		if ((await run("git", ["status", "--porcelain"], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} })).stdout.trim() !== "") return false;
-		return true;
-	} catch (err) {
-		console.error("Error checking git status:", err);
-		return false;
+//#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;
+		});
+		function doesBranchExist(branch) {
+			return listBranches.pipe(Effect.map((branches) => branches.includes(branch)));
+		}
+		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 writeEmptyCommit(message) {
+			return execGitCommandIfNotDry([
+				"commit",
+				"--allow-empty",
+				"-m",
+				message
+			]);
+		}
+		function pushChanges(branch, remote = "origin") {
+			return execGitCommandIfNotDry([
+				"push",
+				remote,
+				branch
+			]);
+		}
+		function forcePushChanges(branch, remote = "origin") {
+			return execGitCommandIfNotDry([
+				"push",
+				"--force-with-lease",
+				remote,
+				branch
+			]);
+		}
+		function readFile(filePath, ref = "HEAD") {
+			return execGitCommand(["show", `${ref}:${filePath}`]);
+		}
+		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,
+				writeEmpty: writeEmptyCommit,
+				push: pushChanges,
+				forcePush: forcePushChanges,
+				get: getCommits,
+				filesChangesBetweenRefs
+			},
+			tags: {
+				mostRecentForPackage: getMostRecentPackageTag,
+				create: createTag,
+				push: pushTag
+			},
+			workspace: {
+				readFile,
+				isWithinRepository,
+				isWorkingDirectoryClean,
+				assertWorkspaceReady
+			}
+		};
+	}),
+	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
+			})));
+		}
+		function createPullRequest(options) {
+			return makeRequest("pulls", PullRequestSchema, {
+				method: "POST",
+				body: JSON.stringify(options)
+			}).pipe(Effect.mapError((e) => new GitHubError({
+				message: e.message,
+				operation: "createPullRequest",
+				cause: e.cause
+			})));
+		}
+		const prBodyTemplate = `## Release Summary
+
+This PR prepares the release of <%= it.count %> package<%= it.count === 1 ? "" : "s" %>:
+
+<% for (const release of it.releases) { %>
+- **<%= release.packageName %>**: \`<%= release.previousVersion %>\` → \`<%= release.version %>\`
+<% } %>
+
+## 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,
+			createPullRequest,
+			updatePullRequest,
+			generateReleasePRBody
+		};
+	}),
+	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();
+		});
+		return {
+			fetchPackument,
+			versionExists,
+			getLatestVersion,
+			publish
+		};
+	}),
+	dependencies: [NodeCommandExecutor.layer]
+}) {};
+
+//#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.optional(Schema.String),
+	private: Schema.optional(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;
+		});
+		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;
+		}
+		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}`;
 }
-/**
-* 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
-*/
-async function doesBranchExist(branch, workspaceRoot) {
-	try {
-		await run("git", [
-			"rev-parse",
-			"--verify",
-			branch
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return true;
-	} catch {
-		return false;
+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 {
+		updated: changed,
+		next: changed ? next : record
+	};
 }
-/**
-* Pull latest changes from remote branch
-* @param branch - The branch name to pull from
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if pull succeeded, false otherwise
-*/
-async function pullLatestChanges(branch, workspaceRoot) {
-	try {
-		await run("git", [
-			"pull",
-			"origin",
-			branch
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		return true;
-	} catch {
-		return false;
-	}
+var PackageUpdaterService = class extends Effect.Service()("@ucdjs/release-scripts/PackageUpdaterService", {
+	effect: Effect.gen(function* () {
+		const workspace = yield* WorkspaceService;
+		function applyReleases(allPackages, releases) {
+			const releaseMap = /* @__PURE__ */ new Map();
+			for (const release of releases) releaseMap.set(release.package.name, release.newVersion);
+			return Effect.all(allPackages.map((pkg) => Effect.gen(function* () {
+				const releaseVersion = releaseMap.get(pkg.name);
+				const nextJson = { ...pkg.packageJson };
+				let updated = false;
+				if (releaseVersion && pkg.packageJson.version !== releaseVersion) {
+					nextJson.version = releaseVersion;
+					updated = true;
+				}
+				const depsResult = updateDependencyRecord(pkg.packageJson.dependencies, releaseMap);
+				if (depsResult.updated) {
+					nextJson.dependencies = depsResult.next;
+					updated = true;
+				}
+				const devDepsResult = updateDependencyRecord(pkg.packageJson.devDependencies, releaseMap);
+				if (devDepsResult.updated) {
+					nextJson.devDependencies = devDepsResult.next;
+					updated = true;
+				}
+				const peerDepsResult = updateDependencyRecord(pkg.packageJson.peerDependencies, releaseMap);
+				if (peerDepsResult.updated) {
+					nextJson.peerDependencies = peerDepsResult.next;
+					updated = true;
+				}
+				if (!updated) return "skipped";
+				return yield* workspace.writePackageJson(pkg.path, nextJson).pipe(Effect.map(() => "written"));
+			})));
+		}
+		return { applyReleases };
+	}),
+	dependencies: [WorkspaceService.Default]
+}) {};
+
+//#endregion
+//#region src/services/version-calculator.service.ts
+const BUMP_PRIORITY = {
+	none: 0,
+	patch: 1,
+	minor: 2,
+	major: 3
+};
+function maxBump(current, incoming) {
+	return (BUMP_PRIORITY[incoming] ?? 0) > (BUMP_PRIORITY[current] ?? 0) ? incoming : current;
 }
-/**
-* Create a new git branch
-* @param branch - The new branch name
-* @param base - The base branch to create from
-* @param workspaceRoot - The root directory of the workspace
-*/
-async function createBranch(branch, base, workspaceRoot) {
-	await runIfNotDry("git", [
-		"checkout",
-		"-b",
-		branch,
-		base
-	], { nodeOptions: { cwd: workspaceRoot } });
+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";
 }
-/**
-* Checkout a git branch
-* @param branch - The branch name to checkout
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if checkout succeeded, false otherwise
-*/
-async function checkoutBranch(branch, workspaceRoot) {
-	try {
-		await run("git", ["checkout", branch], { nodeOptions: { cwd: workspaceRoot } });
-		return true;
-	} catch {
-		return false;
-	}
+function determineBump(commits) {
+	return commits.reduce((acc, commit) => maxBump(acc, bumpFromCommit(commit)), "none");
 }
-/**
-* Get the current branch name
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to the current branch name
-*/
-async function getCurrentBranch(workspaceRoot) {
-	return (await run("git", [
-		"rev-parse",
-		"--abbrev-ref",
-		"HEAD"
-	], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} })).stdout.trim();
+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/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}`)));
+		}));
+	});
 }
 /**
-* Rebase current branch onto another branch
-* @param ontoBranch - The target branch to rebase onto
-* @param workspaceRoot - The root directory of the workspace
+* 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)
+*
+* 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 rebaseBranch(ontoBranch, workspaceRoot) {
-	await run("git", ["rebase", ontoBranch], { nodeOptions: { cwd: workspaceRoot } });
+function mergeCommitsAffectingGloballyIntoPackage(packages, mode) {
+	return Effect.gen(function* () {
+		const git = yield* GitService;
+		if (mode === "none") return packages;
+		const [oldestCommitSha, newestCommitSha] = findCommitRange(packages);
+		if (oldestCommitSha == null || newestCommitSha == null) return packages;
+		const allCommits = yield* git.commits.get({
+			from: oldestCommitSha,
+			to: newestCommitSha,
+			folder: "."
+		});
+		const affectedFilesPerCommit = yield* git.commits.filesChangesBetweenRefs(oldestCommitSha, newestCommitSha);
+		const commitTimestamps = new Map(allCommits.map((c) => [c.hash, new Date(c.date).getTime()]));
+		const packagePaths = new Set(packages.map((p) => p.path));
+		const result = /* @__PURE__ */ new Map();
+		for (const pkg of packages) {
+			const lastTag = yield* git.tags.mostRecentForPackage(pkg.name);
+			const cutoffTimestamp = lastTag ? commitTimestamps.get(lastTag.sha) ?? 0 : 0;
+			const globalCommits = [];
+			for (const commit of allCommits) {
+				const commitTimestamp = commitTimestamps.get(commit.hash);
+				if (commitTimestamp == null || commitTimestamp <= cutoffTimestamp) continue;
+				const files = affectedFilesPerCommit.get(commit.hash);
+				if (!files) continue;
+				if (isGlobalCommit(files, packagePaths)) if (mode === "dependencies") {
+					if (files.some((file) => isDependencyFile(file))) globalCommits.push(commit);
+				} else globalCommits.push(commit);
+			}
+			result.set(pkg.name, globalCommits);
+		}
+		return yield* Effect.succeed(packages.map((pkg) => ({
+			...pkg,
+			globalCommits: result.get(pkg.name) || []
+		})));
+	});
 }
 /**
-* Check if local branch is ahead of remote (has commits to push)
-* @param branch - The branch name to check
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if local is ahead, false otherwise
+* 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
 */
-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 {
+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 there are any changes to commit (staged or unstaged)
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if there are changes, false otherwise
+* Files that are considered dependency-related in a monorepo.
 */
-async function hasChangesToCommit(workspaceRoot) {
-	return (await run("git", ["status", "--porcelain"], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} })).stdout.trim() !== "";
-}
+const DEPENDENCY_FILES = new Set([
+	"package.json",
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-workspace.yaml"
+]);
 /**
-* Commit changes with a message
-* @param message - The commit message
-* @param workspaceRoot - The root directory of the workspace
-* @returns Promise resolving to true if commit was made, false if there were no changes
+* 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.)
 */
-async function commitChanges(message, workspaceRoot) {
-	await run("git", ["add", "."], { nodeOptions: { cwd: workspaceRoot } });
-	if (!await hasChangesToCommit(workspaceRoot)) return false;
-	await run("git", [
-		"commit",
-		"-m",
-		message
-	], { nodeOptions: { cwd: workspaceRoot } });
-	return true;
+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}`));
 }
 /**
-* Push branch to remote
-* @param branch - The branch name to push
-* @param workspaceRoot - The root directory of the workspace
-* @param options - Push options
-* @param options.force - Force push (overwrite remote)
-* @param options.forceWithLease - Force push with safety check (won't overwrite unexpected changes)
+* Finds the oldest and newest commits across all packages.
+*
+* This establishes the overall time range we need to analyze for global commits.
+*
+* @param packages - Array of packages with their commits
+* @returns Tuple of [oldestCommitSha, newestCommitSha], or [null, null] if no commits found
 */
-async function pushBranch(branch, workspaceRoot, options) {
-	const args = [
-		"push",
-		"origin",
-		branch
-	];
-	if (options?.forceWithLease) args.push("--force-with-lease");
-	else if (options?.force) args.push("--force");
-	await run("git", args, { nodeOptions: { cwd: workspaceRoot } });
+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/github.ts
-async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
-	try {
-		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls?state=open&head=${branch}`, { headers: {
-			Accept: "application/vnd.github.v3+json",
-			Authorization: `token ${githubToken}`
-		} });
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pulls = await res.json();
-		if (pulls == null || !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
-		};
-		console.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
-		return pullRequest;
-	} catch (err) {
-		console.error("Error fetching pull request:", err);
-		return null;
-	}
-}
-async function upsertPullRequest({ owner, repo, title, body, head, base, pullNumber, githubToken }) {
-	try {
-		const isUpdate = pullNumber != null;
-		const url = isUpdate ? `https://api.github.com/repos/${owner}/${repo}/pulls/${pullNumber}` : `https://api.github.com/repos/${owner}/${repo}/pulls`;
-		const method = isUpdate ? "PATCH" : "POST";
-		const requestBody = isUpdate ? {
-			title,
-			body
-		} : {
-			title,
-			body,
-			head,
-			base
-		};
-		const res = await fetch(url, {
-			method,
-			headers: {
-				Accept: "application/vnd.github.v3+json",
-				Authorization: `token ${githubToken}`
-			},
-			body: JSON.stringify(requestBody)
+//#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;
+		let releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
+		const isNewRelease = !releasePullRequest;
+		const branchExists = yield* git.branches.exists(config.branch.release);
+		if (!branchExists) {
+			yield* Console.log(`🌿 Creating release branch "${config.branch.release}" from "${config.branch.default}"...`);
+			yield* git.branches.create(config.branch.release, config.branch.default);
+			yield* Console.log(`✅ Release branch created.`);
+		}
+		if ((yield* git.branches.get) !== config.branch.release) {
+			yield* git.branches.checkout(config.branch.release);
+			yield* Console.log(`✅ Checked out to release branch "${config.branch.release}".`);
+		}
+		if (!isNewRelease || branchExists) {
+			yield* Console.log(`🔄 Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
+			yield* git.branches.rebase(config.branch.default);
+			yield* Console.log(`✅ Rebase complete.`);
+		}
+		const overrides = yield* loadOverrides({
+			sha: config.branch.default,
+			overridesPath: ".github/ucdjs-release.overrides.json"
 		});
-		if (!res.ok) throw new Error(`GitHub API request failed with status ${res.status}`);
-		const pr = await res.json();
-		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";
-		console.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
-		};
-	} catch (err) {
-		console.error(`Error upserting pull request:`, err);
-		throw err;
-	}
-}
-function generatePullRequestBody(updates, _body) {
-	const lines = [];
-	lines.push("## Packages");
-	lines.push("");
-	const directChanges = updates.filter((u) => u.hasDirectChanges);
-	const dependencyUpdates = updates.filter((u) => !u.hasDirectChanges);
-	if (directChanges.length > 0) {
-		lines.push("### Direct Changes");
-		lines.push("");
-		for (const update of directChanges) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (${update.bumpType})`);
-		lines.push("");
-	}
-	if (dependencyUpdates.length > 0) {
-		lines.push("### Dependency Updates");
-		lines.push("");
-		for (const update of dependencyUpdates) lines.push(`- **${update.package.name}**: ${update.currentVersion} → ${update.newVersion} (dependencies changed)`);
-		lines.push("");
-	}
-	lines.push("---");
-	lines.push("");
-	lines.push("This release PR was automatically generated.");
-	return lines.join("\n");
+		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);
+		}
+		yield* Console.log(`✅ Generated ${changelogFiles.length} changelog file${changelogFiles.length === 1 ? "" : "s"}.`);
+		const filesToStage = [...releases.map((r) => `${r.package.path}/package.json`), ...changelogFiles];
+		yield* Console.log(`📌 Staging ${filesToStage.length} file${filesToStage.length === 1 ? "" : "s"}...`);
+		yield* git.commits.stage(filesToStage);
+		const commitMessage = `chore(release): prepare release
+
+${releasesCount} package${releasesCount === 1 ? "" : "s"} updated:
+${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
+		yield* Console.log("💾 Creating commit...");
+		yield* git.commits.write(commitMessage);
+		yield* Console.log("✅ Commit created.");
+		yield* Console.log(`⬆️  Pushing to "${config.branch.release}"...`);
+		if (isNewRelease && !branchExists) yield* git.commits.push(config.branch.release);
+		else yield* git.commits.forcePush(config.branch.release);
+		yield* Console.log(`✅ Push complete.`);
+		const prBody = yield* github.generateReleasePRBody(releases.map((r) => ({
+			packageName: r.package.name,
+			version: r.newVersion,
+			previousVersion: r.package.version
+		})));
+		if (isNewRelease) {
+			yield* Console.log("📋 Creating release pull request...");
+			releasePullRequest = yield* github.createPullRequest({
+				title: config.pullRequest.title,
+				body: prBody,
+				head: config.branch.release,
+				base: config.branch.default,
+				draft: true
+			});
+			yield* Console.log(`✅ Release pull request #${releasePullRequest.number} created.`);
+		} else {
+			yield* Console.log("📄 Updating pull request...");
+			yield* github.updatePullRequest(releasePullRequest.number, { body: prBody });
+			yield* Console.log("✅ Pull request updated.");
+		}
+		yield* Console.log(`\n🎉 Release preparation complete! View PR: #${releasePullRequest.number}`);
+	});
 }
 
 //#endregion
-//#region src/prompts.ts
-async function promptPackageSelection(packages) {
-	const response = await prompts({
-		type: "multiselect",
-		name: "selectedPackages",
-		message: "Select packages to release",
-		choices: packages.map((pkg) => ({
-			title: `${pkg.name} (${pkg.version})`,
-			value: pkg.name,
-			selected: true
-		})),
-		min: 1,
-		hint: "Space to select/deselect. Return to submit."
-	});
-	if (!response.selectedPackages || response.selectedPackages.length === 0) throw new Error("No packages selected");
-	return response.selectedPackages;
+//#region src/publish.ts
+function isPrerelease(version) {
+	const parsed = semver.parse(version);
+	return parsed !== null && parsed.prerelease.length > 0;
 }
-async function promptVersionOverride(packageName, currentVersion, suggestedVersion, suggestedBumpType) {
-	const choices = [{
-		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
-		value: "suggested"
-	}];
-	for (const bumpType of [
-		"patch",
-		"minor",
-		"major"
-	]) if (bumpType !== suggestedBumpType) {
-		const version = calculateNewVersion(currentVersion, bumpType);
-		choices.push({
-			title: `${bumpType}: ${version}`,
-			value: bumpType
-		});
-	}
-	choices.push({
-		title: "Custom version",
-		value: "custom"
+function getDistTag(version) {
+	return isPrerelease(version) ? "next" : "latest";
+}
+function buildPackage(packagePath) {
+	return Effect.gen(function* () {
+		const executor = yield* CommandExecutor.CommandExecutor;
+		const command = Command.make("pnpm", "run", "build").pipe(Command.workingDirectory(packagePath));
+		return (yield* executor.string(command).pipe(Effect.mapError((err) => /* @__PURE__ */ new Error(`Failed to build package at ${packagePath}: ${err.message}`)))).trim();
 	});
-	const response = await prompts([{
-		type: "select",
-		name: "choice",
-		message: `${packageName} (${currentVersion}):`,
-		choices,
-		initial: 0
-	}, {
-		type: (prev) => prev === "custom" ? "text" : null,
-		name: "customVersion",
-		message: "Enter custom version:",
-		initial: suggestedVersion,
-		validate: (value) => {
-			return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(value) || "Invalid semver version (e.g., 1.0.0)";
-		}
-	}]);
-	if (response.choice === "suggested") return suggestedVersion;
-	else if (response.choice === "custom") return response.customVersion;
-	else return calculateNewVersion(currentVersion, response.choice);
 }
-async function promptVersionOverrides(packages) {
-	const overrides = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const newVersion = await promptVersionOverride(pkg.name, pkg.currentVersion, pkg.suggestedVersion, pkg.bumpType);
-		overrides.set(pkg.name, newVersion);
-	}
-	return overrides;
+function constructPublishProgram(config) {
+	return Effect.gen(function* () {
+		const git = yield* GitService;
+		const npm = yield* NPMService;
+		const workspace = yield* WorkspaceService;
+		const dependencyGraph = yield* DependencyGraphService;
+		yield* git.workspace.assertWorkspaceReady;
+		const currentBranch = yield* git.branches.get;
+		if (currentBranch !== config.branch.default) return yield* Effect.fail(/* @__PURE__ */ new Error(`Publish must be run on the default branch "${config.branch.default}". Current branch: "${currentBranch}"`));
+		yield* Console.log(`✅ On default branch "${config.branch.default}".`);
+		const publicPackages = (yield* workspace.discoverWorkspacePackages).filter((pkg) => !pkg.packageJson.private);
+		yield* Console.log(`📦 Found ${publicPackages.length} public package${publicPackages.length === 1 ? "" : "s"} to check.`);
+		const orderedPackages = yield* dependencyGraph.topologicalOrder(publicPackages);
+		const results = [];
+		for (const updateOrder of orderedPackages) {
+			const pkg = updateOrder.package;
+			const version = pkg.version;
+			const tagName = `${pkg.name}@${version}`;
+			if (yield* npm.versionExists(pkg.name, version)) {
+				yield* Console.log(`⏭️  Skipping ${pkg.name}@${version} - already published.`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "skipped",
+					reason: "Already published to npm"
+				});
+				continue;
+			}
+			yield* Console.log(`🔨 Building ${pkg.name}...`);
+			yield* buildPackage(pkg.path);
+			yield* Console.log(`✅ Build complete for ${pkg.name}.`);
+			const distTag = getDistTag(version);
+			yield* Console.log(`🚀 Publishing ${pkg.name}@${version} with tag "${distTag}"...`);
+			const publishResult = yield* npm.publish({
+				packagePath: pkg.path,
+				tagName: distTag,
+				otp: config.npm.otp,
+				provenance: config.npm.provenance,
+				dryRun: config.dryRun
+			}).pipe(Effect.map(() => ({ success: true })), Effect.catchAll((err) => Effect.succeed({
+				success: false,
+				error: err
+			})));
+			if (publishResult.success) {
+				yield* Console.log(`✅ Published ${pkg.name}@${version}.`);
+				if (!config.dryRun) {
+					yield* Console.log(`🏷️  Creating tag ${tagName}...`);
+					yield* git.tags.create(tagName, `Release ${tagName}`);
+					yield* git.tags.push(tagName);
+					yield* Console.log(`✅ Tag ${tagName} created and pushed.`);
+				} else yield* Console.log(`🏷️  [Dry Run] Would create and push tag ${tagName}.`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "published"
+				});
+			} else {
+				const error = publishResult.error;
+				yield* Console.log(`❌ Failed to publish ${pkg.name}@${version}: ${error.message}`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "failed",
+					reason: error.message
+				});
+			}
+		}
+		const published = results.filter((r) => r.status === "published");
+		const skipped = results.filter((r) => r.status === "skipped");
+		const failed = results.filter((r) => r.status === "failed");
+		yield* Console.log("\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."));
+		}
+		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!");
+	});
 }
 
 //#endregion
-//#region src/workspace.ts
-const debug = createDebugger("ucdjs:release-scripts:workspace");
-function shouldIncludePackage(pkg, options) {
-	if (!options) return true;
-	if (options.excludePrivate && pkg.private) return false;
-	if (options.included && options.included.length > 0) {
-		if (!options.included.includes(pkg.name)) return false;
-	}
-	if (options.excluded?.includes(pkg.name)) return false;
-	return true;
-}
-async function findWorkspacePackages(workspaceRoot, options) {
-	const result = await run("pnpm", [
-		"-r",
-		"ls",
-		"--json"
-	], { nodeOptions: {
-		cwd: workspaceRoot,
-		stdio: "pipe"
-	} });
-	const rawProjects = JSON.parse(result.stdout);
-	const packages = [];
-	const allPackageNames = new Set(rawProjects.map((p) => p.name));
-	for (const rawProject of rawProjects) {
-		const content = await readFile(join(rawProject.path, "package.json"), "utf-8");
-		const packageJson = JSON.parse(content);
-		if (!shouldIncludePackage(packageJson, options)) {
-			debug?.(`Excluding package ${rawProject.name}`);
-			continue;
-		}
-		const workspaceDeps = extractWorkspaceDependencies(rawProject.dependencies, allPackageNames);
-		const workspaceDevDeps = extractWorkspaceDependencies(rawProject.devDependencies, allPackageNames);
-		packages.push({
-			name: rawProject.name,
-			version: rawProject.version,
-			path: rawProject.path,
-			packageJson,
-			workspaceDependencies: workspaceDeps,
-			workspaceDevDependencies: workspaceDevDeps
-		});
-	}
-	return packages;
+//#region src/verify.ts
+function satisfiesRange(range, version) {
+	return semver.satisfies(version, range, { includePrerelease: true });
 }
-function extractWorkspaceDependencies(dependencies, workspacePackages) {
-	if (!dependencies) return [];
-	return Object.keys(dependencies).filter((dep) => {
-		return workspacePackages.has(dep);
+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)}`)
+		})));
 	});
 }
-function buildDependencyGraph(packages) {
-	const packagesMap = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
+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) {
-		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);
+		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}`
+				});
+			}
 		}
 	}
-	return {
-		packages: packagesMap,
-		dependents
-	};
+	return reasons;
 }
-function getPackageUpdateOrder(graph, changedPackages) {
-	const result = [];
-	const visited = /* @__PURE__ */ new Set();
-	const toUpdate = new Set(changedPackages);
-	const packagesToProcess = new Set(changedPackages);
-	for (const pkg of changedPackages) {
-		const deps = graph.dependents.get(pkg);
-		if (deps) for (const dep of deps) {
-			packagesToProcess.add(dep);
-			toUpdate.add(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}".`);
 		}
-	}
-	function visit(pkgName, level) {
-		if (visited.has(pkgName)) return;
-		visited.add(pkgName);
-		const pkg = graph.packages.get(pkgName);
-		if (!pkg) return;
-		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
-		let maxDepLevel = level;
-		for (const dep of allDeps) if (toUpdate.has(dep)) {
-			visit(dep, level);
-			const depResult = result.find((r) => r.package.name === dep);
-			if (depResult && depResult.level >= maxDepLevel) maxDepLevel = depResult.level + 1;
-		}
-		result.push({
-			package: pkg,
-			level: maxDepLevel
+		const overrides = yield* loadOverrides({
+			sha: releasePullRequest.head.sha,
+			overridesPath: ".github/ucdjs-release.overrides.json"
 		});
-	}
-	for (const pkg of toUpdate) visit(pkg, 0);
-	result.sort((a, b) => a.level - b.level);
-	return result;
+		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
-const isCI = process.env.CI === "true";
-async function release(options) {
-	const { dryRun: dryRun$1 = false, safeguards = true, workspaceRoot = process.cwd(), releaseBranch = "release/next", githubToken } = options;
-	globalOptions.dryRun = dryRun$1;
-	if (githubToken.trim() === "" || githubToken == null) throw new Error("GitHub token is required");
-	const [owner, repo] = options.repo.split("/");
-	if (!owner || !repo) throw new Error(`Invalid repo format: ${options.repo}. Expected "owner/repo".`);
-	if (safeguards && !isWorkingDirectoryClean(workspaceRoot)) {
-		console.error("Working directory is not clean. Please commit or stash your changes before proceeding.");
-		return null;
-	}
-	const { workspacePackages, packagesToAnalyze: initialPackages } = await discoverPackages(workspaceRoot, options);
-	if (initialPackages.length === 0) return null;
-	const isPackagePromptEnabled = options.prompts?.packages !== false;
-	const isPackagesPreConfigured = Array.isArray(options.packages) || typeof options.packages === "object" && options.packages.included != null;
-	let packagesToAnalyze = initialPackages;
-	if (!isCI && isPackagePromptEnabled && !isPackagesPreConfigured) {
-		const selectedNames = await promptPackageSelection(initialPackages);
-		packagesToAnalyze = initialPackages.filter((pkg) => selectedNames.includes(pkg.name));
-	}
-	const changedPackages = await analyzeCommits(packagesToAnalyze, workspaceRoot);
-	if (changedPackages.size === 0) throw new Error("No packages have changes requiring a release");
-	let versionUpdates = calculateVersions(workspacePackages, changedPackages);
-	const isVersionPromptEnabled = options.prompts?.versions !== false;
-	if (!isCI && isVersionPromptEnabled) {
-		const versionOverrides = await promptVersionOverrides(versionUpdates.map((u) => ({
-			name: u.package.name,
-			currentVersion: u.currentVersion,
-			suggestedVersion: u.newVersion,
-			bumpType: u.bumpType
-		})));
-		versionUpdates = versionUpdates.map((update) => {
-			const overriddenVersion = versionOverrides.get(update.package.name);
-			if (overriddenVersion && overriddenVersion !== update.newVersion) return {
-				...update,
-				newVersion: overriddenVersion
-			};
-			return update;
-		});
-	}
-	const allUpdates = createDependentUpdates(getPackageUpdateOrder(buildDependencyGraph(workspacePackages), new Set(versionUpdates.map((u) => u.package.name))), versionUpdates);
-	const currentBranch = await getCurrentBranch(workspaceRoot);
-	const existingPullRequest = await getExistingPullRequest({
-		owner,
-		repo,
-		branch: releaseBranch,
-		githubToken
+//#region src/index.ts
+async function createReleaseScripts(options) {
+	const config = normalizeReleaseScriptsOptions(options);
+	const AppLayer = Layer.mergeAll(ChangelogService.Default, GitService.Default, GitHubService.Default, DependencyGraphService.Default, NPMService.Default, PackageUpdaterService.Default, VersionCalculatorService.Default, WorkspaceService.Default).pipe(Layer.provide(Layer.succeed(ReleaseScriptsOptions, config)), Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer));
+	const runProgram = (program) => {
+		const provided = program.pipe(Effect.provide(AppLayer));
+		return Effect.runPromise(provided);
+	};
+	const safeguardProgram = Effect.gen(function* () {
+		return yield* (yield* GitService).workspace.assertWorkspaceReady;
 	});
-	const prExists = !!existingPullRequest;
-	if (prExists) console.log("Existing pull request found:", existingPullRequest.html_url);
-	else console.log("No existing pull request found, will create new one");
-	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
-	if (!branchExists) {
-		console.log("Creating release branch:", releaseBranch);
-		await createBranch(releaseBranch, currentBranch, workspaceRoot);
-	}
-	if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
-	if (branchExists) {
-		console.log("Pulling latest changes from remote");
-		if (!await pullLatestChanges(releaseBranch, workspaceRoot)) console.log("Warning: Failed to pull latest changes, continuing anyway");
-	}
-	console.log("Rebasing release branch onto", currentBranch);
-	await rebaseBranch(currentBranch, workspaceRoot);
-	await updatePackageJsonFiles(allUpdates);
-	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
-	if (!hasCommitted && !isBranchAhead) {
-		console.log("No changes to commit and branch is in sync with remote");
-		await checkoutBranch(currentBranch, workspaceRoot);
-		if (prExists) {
-			console.log("No updates needed, PR is already up to date");
-			return {
-				updates: allUpdates,
-				prUrl: existingPullRequest.html_url,
-				created: false
-			};
-		} else {
-			console.error("No changes to commit, and no existing PR. Nothing to do.");
-			return null;
-		}
+	try {
+		await runProgram(safeguardProgram);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		await Effect.runPromise(Console.error(`❌ Initialization failed: ${message}`));
+		throw err;
 	}
-	console.log("Pushing changes to remote");
-	await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
-	const prTitle = existingPullRequest?.title || options.pullRequest?.title || "chore: update package versions";
-	const prBody = generatePullRequestBody(allUpdates, options.pullRequest?.body);
-	const pullRequest = await upsertPullRequest({
-		owner,
-		repo,
-		pullNumber: existingPullRequest?.number,
-		title: prTitle,
-		body: prBody,
-		head: releaseBranch,
-		base: currentBranch,
-		githubToken
-	});
-	console.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
-	await checkoutBranch(currentBranch, workspaceRoot);
 	return {
-		updates: allUpdates,
-		prUrl: pullRequest?.html_url,
-		created: !prExists
-	};
-}
-async function discoverPackages(workspaceRoot, options) {
-	let workspacePackages;
-	let packagesToAnalyze;
-	if (typeof options.packages === "boolean" && options.packages === true) {
-		workspacePackages = await findWorkspacePackages(workspaceRoot, { excludePrivate: false });
-		packagesToAnalyze = workspacePackages;
-		return {
-			workspacePackages,
-			packagesToAnalyze
-		};
-	}
-	if (Array.isArray(options.packages)) {
-		const packageNames = options.packages;
-		workspacePackages = await findWorkspacePackages(workspaceRoot, {
-			excludePrivate: false,
-			included: packageNames
-		});
-		packagesToAnalyze = workspacePackages.filter((pkg) => packageNames.includes(pkg.name));
-		if (packagesToAnalyze.length !== packageNames.length) {
-			const found = new Set(packagesToAnalyze.map((p) => p.name));
-			const missing = packageNames.filter((p) => !found.has(p));
-			throw new Error(`Packages not found in workspace: ${missing.join(", ")}`);
+		async verify() {
+			return runProgram(constructVerifyProgram(config));
+		},
+		async prepare() {
+			return runProgram(constructPrepareProgram(config));
+		},
+		async publish() {
+			return runProgram(constructPublishProgram(config));
+		},
+		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;
+				}));
+			}
 		}
-		return {
-			workspacePackages,
-			packagesToAnalyze
-		};
-	}
-	workspacePackages = await findWorkspacePackages(workspaceRoot, options.packages);
-	packagesToAnalyze = workspacePackages;
-	return {
-		workspacePackages,
-		packagesToAnalyze
 	};
 }
-async function analyzeCommits(packages, workspaceRoot) {
-	const changedPackages = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const bump = await analyzePackageCommits(pkg, workspaceRoot);
-		if (bump !== "none") changedPackages.set(pkg.name, bump);
-	}
-	return changedPackages;
-}
-function calculateVersions(allPackages, changedPackages) {
-	const updates = [];
-	for (const [pkgName, bump] of changedPackages) {
-		const pkg = allPackages.find((p) => p.name === pkgName);
-		if (!pkg) continue;
-		updates.push(createVersionUpdate(pkg, bump, true));
-	}
-	return updates;
-}
-async function updatePackageJsonFiles(updates) {
-	await Promise.all(updates.map(async (update) => {
-		const depUpdates = getDependencyUpdates(update.package, updates);
-		await updatePackageJson(update.package, update.newVersion, depUpdates);
-	}));
-}
 
 //#endregion
-export { release };
+export { createReleaseScripts };