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

package/dist/index.mjs

@@ -1,128 +1,57 @@
 import { t as Eta } from "./eta-DAZlmVBQ.mjs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join, relative } from "node:path";
-import farver from "farver";
-import prompts from "prompts";
+import { getCommits, groupByType } 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";
 
-//#region src/operations/semver.ts
-function isValidSemver(version) {
-	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
-}
-function getNextVersion(currentVersion, bump) {
-	if (bump === "none") return currentVersion;
-	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump version for invalid semver: ${currentVersion}`);
-	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
-	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
-	const [, major, minor, patch] = match;
-	let newMajor = Number.parseInt(major, 10);
-	let newMinor = Number.parseInt(minor, 10);
-	let newPatch = Number.parseInt(patch, 10);
-	switch (bump) {
-		case "major":
-			newMajor += 1;
-			newMinor = 0;
-			newPatch = 0;
-			break;
-		case "minor":
-			newMinor += 1;
-			newPatch = 0;
-			break;
-		case "patch":
-			newPatch += 1;
-			break;
+//#region src/operations/changelog-format.ts
+function formatCommitLine({ commit, owner, repo, authors }) {
+	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
+	let line = `${commit.description}`;
+	const references = commit.references ?? [];
+	for (const ref of references) {
+		if (!ref.value) continue;
+		const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
+		if (Number.isNaN(number)) continue;
+		if (ref.type === "issue") {
+			line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
+			continue;
+		}
+		line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
 	}
-	return `${newMajor}.${newMinor}.${newPatch}`;
-}
-function calculateBumpType(oldVersion, newVersion) {
-	if (!isValidSemver(oldVersion) || !isValidSemver(newVersion)) throw new Error(`Cannot calculate bump type for invalid semver: ${oldVersion} or ${newVersion}`);
-	const oldParts = oldVersion.split(".").map(Number);
-	const newParts = newVersion.split(".").map(Number);
-	if (newParts[0] > oldParts[0]) return "major";
-	if (newParts[1] > oldParts[1]) return "minor";
-	if (newParts[2] > oldParts[2]) return "patch";
-	return "none";
+	line += ` ([${commit.shortHash}](${commitUrl}))`;
+	if (authors.length > 0) {
+		const authorList = authors.map((author) => author.login ? `[@${author.login}](https://github.com/${author.login})` : author.name).join(", ");
+		line += ` (by ${authorList})`;
+	}
+	return line;
 }
-
-//#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
+function buildTemplateGroups(options) {
+	const { commits, owner, repo, types, commitAuthors } = options;
+	const grouped = groupByType(commits, {
+		includeNonConventional: false,
+		mergeKeys: Object.fromEntries(Object.entries(types).map(([key, value]) => [key, value.types ?? [key]]))
+	});
+	return Object.entries(types).map(([key, value]) => {
+		const formattedCommits = (grouped.get(key) ?? []).map((commit) => ({ line: formatCommitLine({
+			commit,
+			owner,
+			repo,
+			authors: commitAuthors.get(commit.hash) ?? []
+		}) }));
+		return {
+			name: key,
+			title: value.title,
+			commits: formattedCommits
+		};
 	});
-	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
-	return response.selectedPackages;
-}
-async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion) {
-	const answers = await prompts([{
-		type: "autocomplete",
-		name: "version",
-		message: `${pkg.name}: ${farver.green(pkg.version)}`,
-		choices: [
-			{
-				value: "skip",
-				title: `skip ${farver.dim("(no change)")}`
-			},
-			{
-				value: "major",
-				title: `major ${farver.bold(getNextVersion(pkg.version, "major"))}`
-			},
-			{
-				value: "minor",
-				title: `minor ${farver.bold(getNextVersion(pkg.version, "minor"))}`
-			},
-			{
-				value: "patch",
-				title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
-			},
-			{
-				value: "suggested",
-				title: `suggested ${farver.bold(suggestedVersion)}`
-			},
-			{
-				value: "as-is",
-				title: `as-is ${farver.dim("(keep current version)")}`
-			},
-			{
-				value: "custom",
-				title: "custom"
-			}
-		],
-		initial: suggestedVersion === currentVersion ? 0 : 4
-	}, {
-		type: (prev) => prev === "custom" ? "text" : null,
-		name: "custom",
-		message: "Enter the new version number:",
-		initial: suggestedVersion,
-		validate: (custom) => {
-			if (isValidSemver(custom)) return true;
-			return "That's not a valid version number";
-		}
-	}]);
-	if (!answers.version) return null;
-	if (answers.version === "skip") return null;
-	else if (answers.version === "suggested") return suggestedVersion;
-	else if (answers.version === "custom") {
-		if (!answers.custom) return null;
-		return answers.custom;
-	} else if (answers.version === "as-is") return currentVersion;
-	else return getNextVersion(pkg.version, answers.version);
 }
 
 //#endregion
@@ -210,118 +139,135 @@ if (isDryRun || isVerbose || isForce) {
 }
 
 //#endregion
-//#region src/types/result.ts
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-function err(error) {
-	return {
-		ok: false,
-		error
-	};
-}
-
-//#endregion
-//#region src/core/workspace.ts
-async function discoverWorkspacePackages(workspaceRoot, options) {
-	let workspaceOptions;
-	let explicitPackages;
-	if (options.packages == null || options.packages === true) workspaceOptions = { excludePrivate: false };
-	else if (Array.isArray(options.packages)) {
-		workspaceOptions = {
-			excludePrivate: false,
-			include: options.packages
-		};
-		explicitPackages = options.packages;
-	} else {
-		workspaceOptions = options.packages;
-		if (options.packages.include) explicitPackages = options.packages.include;
+//#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;
 	}
-	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");
+	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)"
+			}
+		});
+		if (!res.ok) {
+			const errorText = await res.text();
+			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
+		}
+		if (res.status === 204) return;
+		return res.json();
 	}
-	const isPackagePromptEnabled = options.prompts?.packages !== false;
-	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
-		const selectedNames = await selectPackagePrompt(workspacePackages);
-		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
+	async getExistingPullRequest(branch) {
+		const head = branch.includes(":") ? branch : `${this.owner}:${branch}`;
+		const endpoint = `/repos/${this.owner}/${this.repo}/pulls?state=open&head=${encodeURIComponent(head)}`;
+		logger.verbose(`Requesting pull request for branch: ${branch} (url: ${this.apiBase}${endpoint})`);
+		const pulls = await this.request(endpoint);
+		if (!Array.isArray(pulls) || pulls.length === 0) return null;
+		const firstPullRequest = pulls[0];
+		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
+		const pullRequest = {
+			number: firstPullRequest.number,
+			title: firstPullRequest.title,
+			body: firstPullRequest.body,
+			draft: firstPullRequest.draft,
+			html_url: firstPullRequest.html_url,
+			head: "head" in firstPullRequest && typeof firstPullRequest.head === "object" && firstPullRequest.head !== null && "sha" in firstPullRequest.head && typeof firstPullRequest.head.sha === "string" ? { sha: firstPullRequest.head.sha } : void 0
+		};
+		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		return pullRequest;
 	}
-	return workspacePackages;
-}
-function toWorkspaceError(operation, error) {
-	return {
-		type: "workspace",
-		operation,
-		message: error instanceof Error ? error.message : String(error)
-	};
-}
-async function wrapWorkspace(operation, fn) {
-	try {
-		return ok(await fn());
-	} catch (error) {
-		return err(toWorkspaceError(operation, error));
+	async upsertPullRequest({ title, body, head, base, pullNumber }) {
+		const isUpdate = typeof pullNumber === "number";
+		const endpoint = isUpdate ? `/repos/${this.owner}/${this.repo}/pulls/${pullNumber}` : `/repos/${this.owner}/${this.repo}/pulls`;
+		const requestBody = isUpdate ? {
+			title,
+			body
+		} : {
+			title,
+			body,
+			head,
+			base,
+			draft: true
+		};
+		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${this.apiBase}${endpoint})`);
+		const pr = await this.request(endpoint, {
+			method: isUpdate ? "PATCH" : "POST",
+			body: JSON.stringify(requestBody)
+		});
+		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
+		};
 	}
-}
-function createWorkspaceOperations(overrides = {}) {
-	return { discoverWorkspacePackages: (workspaceRoot, options) => wrapWorkspace("discoverWorkspacePackages", async () => {
-		if (overrides.discoverWorkspacePackages) return overrides.discoverWorkspacePackages(workspaceRoot, options);
-		return discoverWorkspacePackages(workspaceRoot, options);
-	}) };
-}
-async function findWorkspacePackages(workspaceRoot, options) {
-	try {
-		const result = await run("pnpm", [
-			"-r",
-			"ls",
-			"--json"
-		], { nodeOptions: {
-			cwd: workspaceRoot,
-			stdio: "pipe"
-		} });
-		const rawProjects = JSON.parse(result.stdout);
-		const allPackageNames = new Set(rawProjects.map((p) => p.name));
-		const excludedPackages = /* @__PURE__ */ new Set();
-		const promises = rawProjects.map(async (rawProject) => {
-			const content = await readFile(join(rawProject.path, "package.json"), "utf-8");
-			const packageJson = JSON.parse(content);
-			if (!shouldIncludePackage(packageJson, options)) {
-				excludedPackages.add(rawProject.name);
-				return null;
-			}
-			return {
-				name: rawProject.name,
-				version: rawProject.version,
-				path: rawProject.path,
-				packageJson,
-				workspaceDependencies: Object.keys(rawProject.dependencies || []).filter((dep) => {
-					return allPackageNames.has(dep);
-				}),
-				workspaceDevDependencies: Object.keys(rawProject.devDependencies || []).filter((dep) => {
-					return allPackageNames.has(dep);
-				})
-			};
+	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
+			})
 		});
-		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;
+		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
 	}
-}
-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;
+	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}`);
+		}
+		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}`);
+		}
+		return info;
 	}
-	if (options.exclude?.includes(pkg.name)) return false;
-	return true;
+};
+function createGitHubClient(options) {
+	return new GitHubClient(options);
+}
+function dedentString(str) {
+	const lines = str.split("\n");
+	const minIndent = lines.filter((line) => line.trim().length > 0).reduce((min, line) => Math.min(min, line.search(/\S/)), Infinity);
+	return lines.map((line) => minIndent === Infinity ? line : line.slice(minIndent)).join("\n").trim();
+}
+function generatePullRequestBody(updates, body) {
+	const eta = new Eta();
+	const bodyTemplate = body ? dedentString(body) : DEFAULT_PR_BODY_TEMPLATE;
+	return eta.renderString(bodyTemplate, { packages: updates.map((u) => ({
+		name: u.package.name,
+		currentVersion: u.currentVersion,
+		newVersion: u.newVersion,
+		bumpType: u.bumpType,
+		hasDirectChanges: u.hasDirectChanges
+	})) });
 }
 
 //#endregion
@@ -389,6 +335,11 @@ function normalizeReleaseScriptsOptions(options) {
 		githubToken: token,
 		owner,
 		repo,
+		githubClient: createGitHubClient({
+			owner,
+			repo,
+			githubToken: token
+		}),
 		packages: normalizedPackages,
 		branch: {
 			release: branch.release ?? "release/next",
@@ -411,7 +362,9 @@ function normalizeReleaseScriptsOptions(options) {
 		} : DEFAULT_TYPES,
 		npm: {
 			otp: npm.otp,
-			provenance: npm.provenance ?? true
+			provenance: npm.provenance ?? true,
+			access: npm.access ?? "public",
+			runBuild: npm.runBuild ?? true
 		},
 		prompts: {
 			versions: prompts.versions ?? !isCI,
@@ -421,68 +374,22 @@ function normalizeReleaseScriptsOptions(options) {
 }
 
 //#endregion
-//#region src/operations/changelog-format.ts
-function formatCommitLine({ commit, owner, repo, authors }) {
-	const commitUrl = `https://github.com/${owner}/${repo}/commit/${commit.hash}`;
-	let line = `${commit.description}`;
-	const references = commit.references ?? [];
-	for (const ref of references) {
-		if (!ref.value) continue;
-		const number = Number.parseInt(ref.value.replace(/^#/, ""), 10);
-		if (Number.isNaN(number)) continue;
-		if (ref.type === "issue") {
-			line += ` ([Issue ${ref.value}](https://github.com/${owner}/${repo}/issues/${number}))`;
-			continue;
-		}
-		line += ` ([PR ${ref.value}](https://github.com/${owner}/${repo}/pull/${number}))`;
-	}
-	line += ` ([${commit.shortHash}](${commitUrl}))`;
-	if (authors.length > 0) {
-		const authorList = authors.map((author) => author.login ? `[@${author.login}](https://github.com/${author.login})` : author.name).join(", ");
-		line += ` (by ${authorList})`;
-	}
-	return line;
+//#region src/types.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
 }
-function buildTemplateGroups(options) {
-	const { commits, owner, repo, types, commitAuthors } = options;
-	const grouped = groupByType(commits, {
-		includeNonConventional: false,
-		mergeKeys: Object.fromEntries(Object.entries(types).map(([key, value]) => [key, value.types ?? [key]]))
-	});
-	return Object.entries(types).map(([key, value]) => {
-		const formattedCommits = (grouped.get(key) ?? []).map((commit) => ({ line: formatCommitLine({
-			commit,
-			owner,
-			repo,
-			authors: commitAuthors.get(commit.hash) ?? []
-		}) }));
-		return {
-			name: key,
-			title: value.title,
-			commits: formattedCommits
-		};
-	});
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
 }
 
 //#endregion
 //#region src/core/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) {
-		logger.error("Error checking git status:", err);
-		return false;
-	}
-}
 function toGitError(operation, error) {
 	return {
 		type: "git",
@@ -491,71 +398,16 @@ function toGitError(operation, error) {
 		stderr: (typeof error === "object" && error && "stderr" in error ? String(error.stderr ?? "") : void 0)?.trim() || void 0
 	};
 }
-async function wrapGit(operation, fn) {
+async function isWorkingDirectoryClean(workspaceRoot) {
 	try {
-		return ok(await fn());
+		return ok((await run("git", ["status", "--porcelain"], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} })).stdout.trim() === "");
 	} catch (error) {
-		return err(toGitError(operation, error));
+		return err(toGitError("isWorkingDirectoryClean", error));
 	}
 }
-function createGitOperations(overrides = {}) {
-	return {
-		isWorkingDirectoryClean: (workspaceRoot) => wrapGit("isWorkingDirectoryClean", async () => {
-			if (overrides.isWorkingDirectoryClean) return overrides.isWorkingDirectoryClean(workspaceRoot);
-			return isWorkingDirectoryClean(workspaceRoot);
-		}),
-		doesBranchExist: (branch, workspaceRoot) => wrapGit("doesBranchExist", async () => {
-			if (overrides.doesBranchExist) return overrides.doesBranchExist(branch, workspaceRoot);
-			return doesBranchExist(branch, workspaceRoot);
-		}),
-		getCurrentBranch: (workspaceRoot) => wrapGit("getCurrentBranch", async () => {
-			if (overrides.getCurrentBranch) return overrides.getCurrentBranch(workspaceRoot);
-			return getCurrentBranch(workspaceRoot);
-		}),
-		checkoutBranch: (branch, workspaceRoot) => wrapGit("checkoutBranch", async () => {
-			if (overrides.checkoutBranch) return overrides.checkoutBranch(branch, workspaceRoot);
-			return checkoutBranch(branch, workspaceRoot);
-		}),
-		createBranch: (branch, base, workspaceRoot) => wrapGit("createBranch", async () => {
-			if (overrides.createBranch) {
-				await overrides.createBranch(branch, base, workspaceRoot);
-				return;
-			}
-			await createBranch(branch, base, workspaceRoot);
-		}),
-		pullLatestChanges: (branch, workspaceRoot) => wrapGit("pullLatestChanges", async () => {
-			if (overrides.pullLatestChanges) return overrides.pullLatestChanges(branch, workspaceRoot);
-			return pullLatestChanges(branch, workspaceRoot);
-		}),
-		rebaseBranch: (ontoBranch, workspaceRoot) => wrapGit("rebaseBranch", async () => {
-			if (overrides.rebaseBranch) {
-				await overrides.rebaseBranch(ontoBranch, workspaceRoot);
-				return;
-			}
-			await rebaseBranch(ontoBranch, workspaceRoot);
-		}),
-		isBranchAheadOfRemote: (branch, workspaceRoot) => wrapGit("isBranchAheadOfRemote", async () => {
-			if (overrides.isBranchAheadOfRemote) return overrides.isBranchAheadOfRemote(branch, workspaceRoot);
-			return isBranchAheadOfRemote(branch, workspaceRoot);
-		}),
-		commitChanges: (message, workspaceRoot) => wrapGit("commitChanges", async () => {
-			if (overrides.commitChanges) return overrides.commitChanges(message, workspaceRoot);
-			return commitChanges(message, workspaceRoot);
-		}),
-		pushBranch: (branch, workspaceRoot, options) => wrapGit("pushBranch", async () => {
-			if (overrides.pushBranch) return overrides.pushBranch(branch, workspaceRoot, options);
-			return pushBranch(branch, workspaceRoot, options);
-		}),
-		readFileFromGit: (workspaceRoot, ref, filePath) => wrapGit("readFileFromGit", async () => {
-			if (overrides.readFileFromGit) return overrides.readFileFromGit(workspaceRoot, ref, filePath);
-			return readFileFromGit(workspaceRoot, ref, filePath);
-		}),
-		getMostRecentPackageTag: (workspaceRoot, packageName) => wrapGit("getMostRecentPackageTag", async () => {
-			if (overrides.getMostRecentPackageTag) return overrides.getMostRecentPackageTag(workspaceRoot, packageName);
-			return getMostRecentPackageTag(workspaceRoot, packageName);
-		})
-	};
-}
 /**
 * Check if a git branch exists locally
 * @param {string} branch - The branch name to check
@@ -572,9 +424,9 @@ async function doesBranchExist(branch, workspaceRoot) {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		return true;
+		return ok(true);
 	} catch {
-		return false;
+		return ok(false);
 	}
 }
 /**
@@ -584,17 +436,16 @@ async function doesBranchExist(branch, workspaceRoot) {
 */
 async function getCurrentBranch(workspaceRoot) {
 	try {
-		return (await run("git", [
+		return ok((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;
+		} })).stdout.trim());
+	} catch (error) {
+		return err(toGitError("getCurrentBranch", error));
 	}
 }
 /**
@@ -615,8 +466,9 @@ async function createBranch(branch, base, workspaceRoot) {
 			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`);
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("createBranch", error));
 	}
 }
 async function checkoutBranch(branch, workspaceRoot) {
@@ -628,11 +480,23 @@ async function checkoutBranch(branch, workspaceRoot) {
 		} })).stderr.trim().match(/Switched to branch '(.+)'/);
 		if (match && match[1] === branch) {
 			logger.info(`Successfully switched to branch: ${farver.green(branch)}`);
-			return true;
+			return ok(true);
 		}
-		return false;
-	} catch {
-		return false;
+		return ok(false);
+	} catch (error) {
+		const gitError = toGitError("checkoutBranch", error);
+		logger.error(`Git checkout failed: ${gitError.message}`);
+		if (gitError.stderr) logger.error(`Git stderr: ${gitError.stderr}`);
+		try {
+			const branchResult = await run("git", ["branch", "-a"], { nodeOptions: {
+				cwd: workspaceRoot,
+				stdio: "pipe"
+			} });
+			logger.verbose(`Available branches:\n${branchResult.stdout}`);
+		} catch {
+			logger.verbose("Could not list available branches");
+		}
+		return err(gitError);
 	}
 }
 async function pullLatestChanges(branch, workspaceRoot) {
@@ -645,9 +509,9 @@ async function pullLatestChanges(branch, workspaceRoot) {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		return true;
-	} catch {
-		return false;
+		return ok(true);
+	} catch (error) {
+		return err(toGitError("pullLatestChanges", error));
 	}
 }
 async function rebaseBranch(ontoBranch, workspaceRoot) {
@@ -657,9 +521,9 @@ async function rebaseBranch(ontoBranch, workspaceRoot) {
 			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`);
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("rebaseBranch", error));
 	}
 }
 async function isBranchAheadOfRemote(branch, workspaceRoot) {
@@ -672,9 +536,9 @@ async function isBranchAheadOfRemote(branch, workspaceRoot) {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		return Number.parseInt(result.stdout.trim(), 10) > 0;
+		return ok(Number.parseInt(result.stdout.trim(), 10) > 0);
 	} catch {
-		return true;
+		return ok(true);
 	}
 }
 async function commitChanges(message, workspaceRoot) {
@@ -683,7 +547,8 @@ async function commitChanges(message, workspaceRoot) {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		if (await isWorkingDirectoryClean(workspaceRoot)) return false;
+		const isClean = await isWorkingDirectoryClean(workspaceRoot);
+		if (!isClean.ok || isClean.value) return ok(false);
 		logger.info(`Committing changes: ${farver.dim(message)}`);
 		await runIfNotDry("git", [
 			"commit",
@@ -693,9 +558,9 @@ async function commitChanges(message, workspaceRoot) {
 			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`);
+		return ok(true);
+	} catch (error) {
+		return err(toGitError("commitChanges", error));
 	}
 }
 async function pushBranch(branch, workspaceRoot, options) {
@@ -706,6 +571,14 @@ async function pushBranch(branch, workspaceRoot, options) {
 			branch
 		];
 		if (options?.forceWithLease) {
+			await run("git", [
+				"fetch",
+				"origin",
+				branch
+			], { nodeOptions: {
+				cwd: workspaceRoot,
+				stdio: "pipe"
+			} });
 			args.push("--force-with-lease");
 			logger.info(`Pushing branch: ${farver.green(branch)} ${farver.dim("(with lease)")}`);
 		} else if (options?.force) {
@@ -716,19 +589,19 @@ async function pushBranch(branch, workspaceRoot, options) {
 			cwd: workspaceRoot,
 			stdio: "pipe"
 		} });
-		return true;
-	} catch {
-		exitWithError(`Failed to push branch: ${branch}`, `Make sure you have permission to push to the remote repository`);
+		return ok(true);
+	} catch (error) {
+		return err(toGitError("pushBranch", error));
 	}
 }
 async function readFileFromGit(workspaceRoot, ref, filePath) {
 	try {
-		return (await run("git", ["show", `${ref}:${filePath}`], { nodeOptions: {
+		return ok((await run("git", ["show", `${ref}:${filePath}`], { nodeOptions: {
 			cwd: workspaceRoot,
 			stdio: "pipe"
-		} })).stdout;
+		} })).stdout);
 	} catch {
-		return null;
+		return ok(null);
 	}
 }
 async function getMostRecentPackageTag(workspaceRoot, packageName) {
@@ -742,11 +615,10 @@ async function getMostRecentPackageTag(workspaceRoot, packageName) {
 			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;
+		if (tags.length === 0) return ok(void 0);
+		return ok(tags.reverse()[0]);
+	} catch (error) {
+		return err(toGitError("getMostRecentPackageTag", error));
 	}
 }
 /**
@@ -793,11 +665,65 @@ async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
 			if (currentSha === null) continue;
 			commitsMap.get(currentSha).push(trimmedLine);
 		}
-		return commitsMap;
-	} catch {
-		return null;
+		return ok(commitsMap);
+	} catch (error) {
+		return err(toGitError("getGroupedFilesByCommitSha", error));
+	}
+}
+/**
+* Create a git tag for a package release
+* @param packageName - The package name (e.g., "@scope/name")
+* @param version - The version to tag (e.g., "1.2.3")
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function createPackageTag(packageName, version, workspaceRoot) {
+	const tagName = `${packageName}@${version}`;
+	try {
+		logger.info(`Creating tag: ${farver.green(tagName)}`);
+		await runIfNotDry("git", ["tag", tagName], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("createPackageTag", error));
+	}
+}
+/**
+* Push a specific tag to the remote repository
+* @param tagName - The tag name to push
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function pushTag(tagName, workspaceRoot) {
+	try {
+		logger.info(`Pushing tag: ${farver.green(tagName)}`);
+		await runIfNotDry("git", [
+			"push",
+			"origin",
+			tagName
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("pushTag", error));
 	}
 }
+/**
+* Create and push a package tag in one operation
+* @param packageName - The package name
+* @param version - The version to tag
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function createAndPushPackageTag(packageName, version, workspaceRoot) {
+	const createResult = await createPackageTag(packageName, version, workspaceRoot);
+	if (!createResult.ok) return createResult;
+	return pushTag(`${packageName}@${version}`, workspaceRoot);
+}
 
 //#endregion
 //#region src/core/changelog.ts
@@ -833,7 +759,7 @@ async function updateChangelog(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));
+	logger.verbose("Existing content found: ", existingContent.ok && Boolean(existingContent.value));
 	const newEntry = await generateChangelogEntry({
 		packageName: workspacePackage.name,
 		version,
@@ -847,13 +773,13 @@ async function updateChangelog(options) {
 		githubClient
 	});
 	let updatedContent;
-	if (!existingContent) {
+	if (!existingContent.ok || !existingContent.value) {
 		updatedContent = `# ${workspacePackage.name}\n\n${newEntry}\n`;
 		await writeFile(changelogPath, updatedContent, "utf-8");
 		return;
 	}
-	const parsed = parseChangelog(existingContent);
-	const lines = existingContent.split("\n");
+	const parsed = parseChangelog(existingContent.value);
+	const lines = existingContent.value.split("\n");
 	const existingVersionIndex = parsed.versions.findIndex((v) => v.version === version);
 	if (existingVersionIndex !== -1) {
 		const existingVersion = parsed.versions[existingVersionIndex];
@@ -944,269 +870,252 @@ function parseChangelog(content) {
 }
 
 //#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;
+//#region src/operations/semver.ts
+function isValidSemver(version) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version);
+}
+function getNextVersion(currentVersion, bump) {
+	if (bump === "none") return currentVersion;
+	if (!isValidSemver(currentVersion)) throw new Error(`Cannot bump version for invalid semver: ${currentVersion}`);
+	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+	if (!match) throw new Error(`Invalid semver version: ${currentVersion}`);
+	const [, major, minor, patch] = match;
+	let newMajor = Number.parseInt(major, 10);
+	let newMinor = Number.parseInt(minor, 10);
+	let newPatch = Number.parseInt(patch, 10);
+	switch (bump) {
+		case "major":
+			newMajor += 1;
+			newMinor = 0;
+			newPatch = 0;
+			break;
+		case "minor":
+			newMinor += 1;
+			newPatch = 0;
+			break;
+		case "patch":
+			newPatch += 1;
+			break;
 	}
-	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)"
+	return `${newMajor}.${newMinor}.${newPatch}`;
+}
+function calculateBumpType(oldVersion, newVersion) {
+	if (!isValidSemver(oldVersion) || !isValidSemver(newVersion)) throw new Error(`Cannot calculate bump type for invalid semver: ${oldVersion} or ${newVersion}`);
+	const oldParts = oldVersion.split(".").map(Number);
+	const newParts = newVersion.split(".").map(Number);
+	if (newParts[0] > oldParts[0]) return "major";
+	if (newParts[1] > oldParts[1]) return "minor";
+	if (newParts[2] > oldParts[2]) return "patch";
+	return "none";
+}
+
+//#endregion
+//#region src/core/prompts.ts
+async function selectPackagePrompt(packages) {
+	const response = await prompts({
+		type: "multiselect",
+		name: "selectedPackages",
+		message: "Select packages to release",
+		choices: packages.map((pkg) => ({
+			title: `${pkg.name} (${farver.bold(pkg.version)})`,
+			value: pkg.name,
+			selected: true
+		})),
+		min: 1,
+		hint: "Space to select/deselect. Return to submit.",
+		instructions: false
+	});
+	if (!response.selectedPackages || response.selectedPackages.length === 0) return [];
+	return response.selectedPackages;
+}
+async function selectVersionPrompt(workspaceRoot, pkg, currentVersion, suggestedVersion) {
+	const answers = await prompts([{
+		type: "autocomplete",
+		name: "version",
+		message: `${pkg.name}: ${farver.green(pkg.version)}`,
+		choices: [
+			{
+				value: "skip",
+				title: `skip ${farver.dim("(no change)")}`
+			},
+			{
+				value: "major",
+				title: `major ${farver.bold(getNextVersion(pkg.version, "major"))}`
+			},
+			{
+				value: "minor",
+				title: `minor ${farver.bold(getNextVersion(pkg.version, "minor"))}`
+			},
+			{
+				value: "patch",
+				title: `patch ${farver.bold(getNextVersion(pkg.version, "patch"))}`
+			},
+			{
+				value: "suggested",
+				title: `suggested ${farver.bold(suggestedVersion)}`
+			},
+			{
+				value: "as-is",
+				title: `as-is ${farver.dim("(keep current version)")}`
+			},
+			{
+				value: "custom",
+				title: "custom"
 			}
-		});
-		if (!res.ok) {
-			const errorText = await res.text();
-			throw new Error(`GitHub API request failed with status ${res.status}: ${errorText || "No response body"}`);
-		}
-		if (res.status === 204) return;
-		return res.json();
-	}
-	async getExistingPullRequest(branch) {
-		const head = branch.includes(":") ? branch : `${this.owner}:${branch}`;
-		const endpoint = `/repos/${this.owner}/${this.repo}/pulls?state=open&head=${encodeURIComponent(head)}`;
-		logger.verbose(`Requesting pull request for branch: ${branch} (url: ${this.apiBase}${endpoint})`);
-		const pulls = await this.request(endpoint);
-		if (!Array.isArray(pulls) || pulls.length === 0) return null;
-		const firstPullRequest = pulls[0];
-		if (typeof firstPullRequest !== "object" || firstPullRequest === null || !("number" in firstPullRequest) || typeof firstPullRequest.number !== "number" || !("title" in firstPullRequest) || typeof firstPullRequest.title !== "string" || !("body" in firstPullRequest) || typeof firstPullRequest.body !== "string" || !("draft" in firstPullRequest) || typeof firstPullRequest.draft !== "boolean" || !("html_url" in firstPullRequest) || typeof firstPullRequest.html_url !== "string") throw new TypeError("Pull request data validation failed");
-		const pullRequest = {
-			number: firstPullRequest.number,
-			title: firstPullRequest.title,
-			body: firstPullRequest.body,
-			draft: firstPullRequest.draft,
-			html_url: firstPullRequest.html_url,
-			head: "head" in firstPullRequest && typeof firstPullRequest.head === "object" && firstPullRequest.head !== null && "sha" in firstPullRequest.head && typeof firstPullRequest.head.sha === "string" ? { sha: firstPullRequest.head.sha } : void 0
-		};
-		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
-		return pullRequest;
-	}
-	async upsertPullRequest({ title, body, head, base, pullNumber }) {
-		const isUpdate = typeof pullNumber === "number";
-		const endpoint = isUpdate ? `/repos/${this.owner}/${this.repo}/pulls/${pullNumber}` : `/repos/${this.owner}/${this.repo}/pulls`;
-		const requestBody = isUpdate ? {
-			title,
-			body
-		} : {
-			title,
-			body,
-			head,
-			base,
-			draft: true
-		};
-		logger.verbose(`${isUpdate ? "Updating" : "Creating"} pull request (url: ${this.apiBase}${endpoint})`);
-		const pr = await this.request(endpoint, {
-			method: isUpdate ? "PATCH" : "POST",
-			body: JSON.stringify(requestBody)
-		});
-		if (typeof pr !== "object" || pr === null || !("number" in pr) || typeof pr.number !== "number" || !("title" in pr) || typeof pr.title !== "string" || !("body" in pr) || typeof pr.body !== "string" || !("draft" in pr) || typeof pr.draft !== "boolean" || !("html_url" in pr) || typeof pr.html_url !== "string") throw new TypeError("Pull request data validation failed");
-		const action = isUpdate ? "Updated" : "Created";
-		logger.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
-		return {
-			number: pr.number,
-			title: pr.title,
-			body: pr.body,
-			draft: pr.draft,
-			html_url: pr.html_url
-		};
-	}
-	async setCommitStatus({ sha, state, targetUrl, description, context }) {
-		const endpoint = `/repos/${this.owner}/${this.repo}/statuses/${sha}`;
-		logger.verbose(`Setting commit status on ${sha} to ${state} (url: ${this.apiBase}${endpoint})`);
-		await this.request(endpoint, {
-			method: "POST",
-			body: JSON.stringify({
-				state,
-				target_url: targetUrl,
-				description: description || "",
-				context
-			})
-		});
-		logger.info(`Commit status set to ${farver.cyan(state)} for ${farver.gray(sha.substring(0, 7))}`);
-	}
-	async resolveAuthorInfo(info) {
-		if (info.login) return info;
-		try {
-			const q = encodeURIComponent(`${info.email} type:user in:email`);
-			const data = await this.request(`/search/users?q=${q}`);
-			if (!data.items || data.items.length === 0) return info;
-			info.login = data.items[0].login;
-		} catch (err) {
-			logger.warn(`Failed to resolve author info for email ${info.email}: ${err.message}`);
-		}
-		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}`);
+		],
+		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";
 		}
-		return info;
-	}
-};
-function createGitHubClient(options) {
-	return new GitHubClient(options);
+	}]);
+	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);
 }
-function toGitHubError(operation, error) {
+
+//#endregion
+//#region src/core/workspace.ts
+function toWorkspaceError(operation, error) {
 	return {
-		type: "github",
+		type: "workspace",
 		operation,
 		message: error instanceof Error ? error.message : String(error)
 	};
 }
-async function wrapGitHub(operation, fn) {
+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;
 	try {
-		return ok(await fn());
+		workspacePackages = await findWorkspacePackages(workspaceRoot, workspaceOptions);
 	} catch (error) {
-		return err(toGitHubError(operation, error));
+		return err(toWorkspaceError("discoverWorkspacePackages", error));
+	}
+	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 ok(workspacePackages);
 }
-function createGitHubOperations(options, overrides = {}) {
-	const client = createGitHubClient(options);
-	return {
-		getExistingPullRequest: (branch) => wrapGitHub("getExistingPullRequest", async () => {
-			if (overrides.getExistingPullRequest) return overrides.getExistingPullRequest(branch);
-			return client.getExistingPullRequest(branch);
-		}),
-		upsertPullRequest: (input) => wrapGitHub("upsertPullRequest", async () => {
-			if (overrides.upsertPullRequest) return overrides.upsertPullRequest(input);
-			return client.upsertPullRequest(input);
-		}),
-		setCommitStatus: (input) => wrapGitHub("setCommitStatus", async () => {
-			if (overrides.setCommitStatus) {
-				await overrides.setCommitStatus(input);
-				return;
+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;
 			}
-			await client.setCommitStatus(input);
-		}),
-		resolveAuthorInfo: (info) => wrapGitHub("resolveAuthorInfo", async () => {
-			if (overrides.resolveAuthorInfo) return overrides.resolveAuthorInfo(info);
-			return client.resolveAuthorInfo(info);
-		})
-	};
-}
-function dedentString(str) {
-	const lines = str.split("\n");
-	const minIndent = lines.filter((line) => line.trim().length > 0).reduce((min, line) => Math.min(min, line.search(/\S/)), Infinity);
-	return lines.map((line) => minIndent === Infinity ? line : line.slice(minIndent)).join("\n").trim();
+			return {
+				name: rawProject.name,
+				version: rawProject.version,
+				path: rawProject.path,
+				packageJson,
+				workspaceDependencies: Object.keys(rawProject.dependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				}),
+				workspaceDevDependencies: Object.keys(rawProject.devDependencies || []).filter((dep) => {
+					return allPackageNames.has(dep);
+				})
+			};
+		});
+		const packages = await Promise.all(promises);
+		if (excludedPackages.size > 0) logger.info(`Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		return packages.filter((pkg) => pkg !== null);
+	} catch (err) {
+		logger.error("Error discovering workspace packages:", err);
+		throw err;
+	}
 }
-function 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 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/operations/branch.ts
 async function prepareReleaseBranch(options) {
-	const { git, workspaceRoot, releaseBranch, defaultBranch } = options;
-	const currentBranch = await git.getCurrentBranch(workspaceRoot);
+	const { workspaceRoot, releaseBranch, defaultBranch } = options;
+	const currentBranch = await getCurrentBranch(workspaceRoot);
 	if (!currentBranch.ok) return currentBranch;
 	if (currentBranch.value !== defaultBranch) return err({
 		type: "git",
 		operation: "validateBranch",
 		message: `Current branch is '${currentBranch.value}'. Please switch to '${defaultBranch}'.`
 	});
-	const branchExists = await git.doesBranchExist(releaseBranch, workspaceRoot);
+	const branchExists = await doesBranchExist(releaseBranch, workspaceRoot);
 	if (!branchExists.ok) return branchExists;
 	if (!branchExists.value) {
-		const created = await git.createBranch(releaseBranch, defaultBranch, workspaceRoot);
+		const created = await createBranch(releaseBranch, defaultBranch, workspaceRoot);
 		if (!created.ok) return created;
 	}
-	const checkedOut = await git.checkoutBranch(releaseBranch, workspaceRoot);
+	const checkedOut = await checkoutBranch(releaseBranch, workspaceRoot);
 	if (!checkedOut.ok) return checkedOut;
 	if (branchExists.value) {
-		const pulled = await git.pullLatestChanges(releaseBranch, workspaceRoot);
+		const pulled = await pullLatestChanges(releaseBranch, workspaceRoot);
 		if (!pulled.ok) return pulled;
 		if (!pulled.value) logger.warn("Failed to pull latest changes, continuing anyway.");
 	}
-	const rebased = await git.rebaseBranch(defaultBranch, workspaceRoot);
+	const rebased = await rebaseBranch(defaultBranch, workspaceRoot);
 	if (!rebased.ok) return rebased;
 	return ok(void 0);
 }
 async function syncReleaseChanges(options) {
-	const { git, workspaceRoot, releaseBranch, commitMessage, hasChanges } = options;
-	const committed = hasChanges ? await git.commitChanges(commitMessage, workspaceRoot) : ok(false);
+	const { workspaceRoot, releaseBranch, commitMessage, hasChanges } = options;
+	const committed = hasChanges ? await commitChanges(commitMessage, workspaceRoot) : ok(false);
 	if (!committed.ok) return committed;
-	const isAhead = await git.isBranchAheadOfRemote(releaseBranch, workspaceRoot);
+	const isAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
 	if (!isAhead.ok) return isAhead;
 	if (!committed.value && !isAhead.value) return ok(false);
-	const pushed = await git.pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
+	const pushed = await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
 	if (!pushed.ok) return pushed;
 	return ok(true);
 }
 
-//#endregion
-//#region src/operations/calculate.ts
-async function calculateUpdates(options) {
-	const { versioning, workspacePackages, workspaceRoot, showPrompt, overrides, globalCommitMode } = options;
-	const grouped = await versioning.getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
-	if (!grouped.ok) return grouped;
-	const global = await versioning.getGlobalCommitsPerPackage(workspaceRoot, grouped.value, workspacePackages, globalCommitMode);
-	if (!global.ok) return global;
-	const updates = await versioning.calculateAndPrepareVersionUpdates({
-		workspacePackages,
-		packageCommits: grouped.value,
-		workspaceRoot,
-		showPrompt,
-		globalCommitsPerPackage: global.value,
-		overrides
-	});
-	if (!updates.ok) return updates;
-	return updates;
-}
-function ensureHasPackages(packages) {
-	if (packages.length === 0) return err({
-		type: "git",
-		operation: "discoverPackages",
-		message: "No packages found to release"
-	});
-	return {
-		ok: true,
-		value: packages
-	};
-}
-
-//#endregion
-//#region src/operations/pr.ts
-async function syncPullRequest(options) {
-	const { github, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody, updates } = options;
-	const existing = await github.getExistingPullRequest(releaseBranch);
-	if (!existing.ok) return existing;
-	const doesExist = !!existing.value;
-	const title = existing.value?.title || pullRequestTitle || "chore: update package versions";
-	const body = generatePullRequestBody(updates, pullRequestBody);
-	const pr = await github.upsertPullRequest({
-		pullNumber: existing.value?.number,
-		title,
-		body,
-		head: releaseBranch,
-		base: defaultBranch
-	});
-	if (!pr.ok) return pr;
-	return ok({
-		pullRequest: pr.value,
-		created: !doesExist
-	});
-}
-
 //#endregion
 //#region src/versioning/commits.ts
 /**
@@ -1220,7 +1129,8 @@ async function syncPullRequest(options) {
 async function getWorkspacePackageGroupedCommits(workspaceRoot, packages) {
 	const changedPackages = /* @__PURE__ */ new Map();
 	const promises = packages.map(async (pkg) => {
-		const lastTag = await getMostRecentPackageTag(workspaceRoot, pkg.name);
+		const lastTagResult = await getMostRecentPackageTag(workspaceRoot, pkg.name);
+		const lastTag = lastTagResult.ok ? lastTagResult.value : void 0;
 		const allCommits = await getCommits({
 			from: lastTag,
 			to: "HEAD",
@@ -1320,17 +1230,17 @@ async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPack
 	}
 	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) {
+	if (!commitFilesMap.ok) {
 		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`);
+	logger.verbose("Got file lists for commits", `${farver.cyan(commitFilesMap.value.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);
+			const files = commitFilesMap.value.get(commit.shortHash);
 			if (!files) continue;
 			if (isGlobalCommit(workspaceRoot, files, packagePaths)) globalCommitsAffectingPackage.push(commit);
 		}
@@ -1341,7 +1251,7 @@ async function getGlobalCommitsPerPackage(workspaceRoot, packageCommits, allPack
 		}
 		const dependencyCommits = [];
 		for (const commit of globalCommitsAffectingPackage) {
-			const files = commitFilesMap.get(commit.shortHash);
+			const files = commitFilesMap.value.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`);
@@ -1439,6 +1349,51 @@ function getAllAffectedPackages(graph, changedPackages) {
 	return affected;
 }
 /**
+* Calculate the order in which packages should be published
+*
+* Performs topological sorting to ensure dependencies are published before dependents.
+* Assigns a "level" to each package based on its depth in the dependency tree.
+*
+* This is used by the publish command to publish packages in the correct order.
+*
+* @param graph - Dependency graph
+* @param packagesToPublish - Set of package names to publish
+* @returns Array of packages in publish order with their dependency level
+*/
+function getPackagePublishOrder(graph, packagesToPublish) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const toUpdate = new Set(packagesToPublish);
+	const packagesToProcess = new Set(packagesToPublish);
+	for (const pkg of packagesToPublish) {
+		const deps = graph.dependents.get(pkg);
+		if (deps) for (const dep of deps) {
+			packagesToProcess.add(dep);
+			toUpdate.add(dep);
+		}
+	}
+	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
+		});
+	}
+	for (const pkg of toUpdate) visit(pkg, 0);
+	result.sort((a, b) => a.level - b.level);
+	return result;
+}
+/**
 * 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.
@@ -1663,79 +1618,89 @@ function getDependencyUpdates(pkg, allUpdates) {
 }
 
 //#endregion
-//#region src/versioning/operations.ts
-function createVersioningOperations() {
-	return {
-		getWorkspacePackageGroupedCommits: async (workspaceRoot, packages) => {
-			try {
-				return {
-					ok: true,
-					value: await getWorkspacePackageGroupedCommits(workspaceRoot, packages)
-				};
-			} catch (error) {
-				return {
-					ok: false,
-					error: {
-						type: "git",
-						operation: "getWorkspacePackageGroupedCommits",
-						message: String(error)
-					}
-				};
-			}
-		},
-		getGlobalCommitsPerPackage: async (workspaceRoot, packageCommits, packages, mode) => {
-			try {
-				return {
-					ok: true,
-					value: await getGlobalCommitsPerPackage(workspaceRoot, packageCommits, packages, mode)
-				};
-			} catch (error) {
-				return {
-					ok: false,
-					error: {
-						type: "git",
-						operation: "getGlobalCommitsPerPackage",
-						message: String(error)
-					}
-				};
+//#region src/operations/calculate.ts
+async function calculateUpdates(options) {
+	const { workspacePackages, workspaceRoot, showPrompt, overrides, globalCommitMode } = options;
+	try {
+		const grouped = await getWorkspacePackageGroupedCommits(workspaceRoot, workspacePackages);
+		return ok(await calculateAndPrepareVersionUpdates({
+			workspacePackages,
+			packageCommits: grouped,
+			workspaceRoot,
+			showPrompt,
+			globalCommitsPerPackage: await getGlobalCommitsPerPackage(workspaceRoot, grouped, workspacePackages, globalCommitMode),
+			overrides
+		}));
+	} catch (error) {
+		return err({
+			type: "git",
+			operation: "calculateUpdates",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function ensureHasPackages(packages) {
+	if (packages.length === 0) return err({
+		type: "git",
+		operation: "discoverWorkspacePackages",
+		message: "No packages found to release"
+	});
+	return ok(packages);
+}
+
+//#endregion
+//#region src/operations/pr.ts
+async function syncPullRequest(options) {
+	const { github, releaseBranch, defaultBranch, pullRequestTitle, pullRequestBody, updates } = options;
+	let existing = null;
+	try {
+		existing = await github.getExistingPullRequest(releaseBranch);
+	} catch (error) {
+		return {
+			ok: false,
+			error: {
+				type: "github",
+				operation: "getExistingPullRequest",
+				message: error instanceof Error ? error.message : String(error)
 			}
-		},
-		calculateAndPrepareVersionUpdates: async (payload) => {
-			try {
-				return {
-					ok: true,
-					value: await calculateAndPrepareVersionUpdates(payload)
-				};
-			} catch (error) {
-				return {
-					ok: false,
-					error: {
-						type: "git",
-						operation: "calculateAndPrepareVersionUpdates",
-						message: String(error)
-					}
-				};
+		};
+	}
+	const doesExist = !!existing;
+	const title = existing?.title || pullRequestTitle || "chore: update package versions";
+	const body = generatePullRequestBody(updates, pullRequestBody);
+	let pr = null;
+	try {
+		pr = await github.upsertPullRequest({
+			pullNumber: existing?.number,
+			title,
+			body,
+			head: releaseBranch,
+			base: defaultBranch
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			error: {
+				type: "github",
+				operation: "upsertPullRequest",
+				message: error instanceof Error ? error.message : String(error)
 			}
-		}
-	};
+		};
+	}
+	return ok({
+		pullRequest: pr,
+		created: !doesExist
+	});
 }
 
 //#endregion
 //#region src/workflows/prepare.ts
 async function prepareWorkflow(options) {
-	const gitOps = createGitOperations();
-	const githubOps = createGitHubOperations({
-		owner: options.owner,
-		repo: options.repo,
-		githubToken: options.githubToken
-	});
-	const workspaceOps = createWorkspaceOperations();
-	const versioningOps = createVersioningOperations();
 	if (options.safeguards) {
-		const clean = await gitOps.isWorkingDirectoryClean(options.workspaceRoot);
+		const clean = await isWorkingDirectoryClean(options.workspaceRoot);
 		if (!clean.ok || !clean.value) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
 	}
-	const discovered = await workspaceOps.discoverWorkspacePackages(options.workspaceRoot, options);
+	const discovered = await discoverWorkspacePackages(options.workspaceRoot, options);
 	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
 	const ensured = ensureHasPackages(discovered.value);
 	if (!ensured.ok) {
@@ -1751,7 +1716,6 @@ async function prepareWorkflow(options) {
 	}
 	logger.emptyLine();
 	const prepareBranchResult = await prepareReleaseBranch({
-		git: gitOps,
 		workspaceRoot: options.workspaceRoot,
 		releaseBranch: options.branch.release,
 		defaultBranch: options.branch.default
@@ -1767,7 +1731,6 @@ async function prepareWorkflow(options) {
 		logger.info("No existing version overrides file found. Continuing...");
 	}
 	const updatesResult = await calculateUpdates({
-		versioning: versioningOps,
 		workspacePackages,
 		workspaceRoot: options.workspaceRoot,
 		showPrompt: options.prompts?.versions !== false,
@@ -1814,13 +1777,11 @@ async function prepareWorkflow(options) {
 	await applyUpdates();
 	if (options.changelog?.enabled) {
 		logger.step("Updating changelogs");
-		const groupedPackageCommits = await versioningOps.getWorkspacePackageGroupedCommits(options.workspaceRoot, workspacePackages);
-		if (!groupedPackageCommits.ok) exitWithError(groupedPackageCommits.error.message);
-		const globalCommitsPerPackage = await versioningOps.getGlobalCommitsPerPackage(options.workspaceRoot, groupedPackageCommits.value, workspacePackages, options.globalCommitMode === "none" ? false : options.globalCommitMode);
-		if (!globalCommitsPerPackage.ok) exitWithError(globalCommitsPerPackage.error.message);
+		const groupedPackageCommits = await getWorkspacePackageGroupedCommits(options.workspaceRoot, workspacePackages);
+		const globalCommitsPerPackage = await getGlobalCommitsPerPackage(options.workspaceRoot, groupedPackageCommits, workspacePackages, options.globalCommitMode === "none" ? false : options.globalCommitMode);
 		const changelogPromises = allUpdates.map((update) => {
-			const pkgCommits = groupedPackageCommits.value.get(update.package.name) || [];
-			const globalCommits = globalCommitsPerPackage.value.get(update.package.name) || [];
+			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`);
@@ -1832,11 +1793,7 @@ async function prepareWorkflow(options) {
 					...options,
 					workspaceRoot: options.workspaceRoot
 				},
-				githubClient: createGitHubClient({
-					owner: options.owner,
-					repo: options.repo,
-					githubToken: options.githubToken
-				}),
+				githubClient: options.githubClient,
 				workspacePackage: update.package,
 				version: update.newVersion,
 				previousVersion: update.currentVersion !== "0.0.0" ? update.currentVersion : void 0,
@@ -1848,7 +1805,6 @@ async function prepareWorkflow(options) {
 		logger.success(`Updated ${updates.length} changelog(s)`);
 	}
 	const hasChangesToPush = await syncReleaseChanges({
-		git: gitOps,
 		workspaceRoot: options.workspaceRoot,
 		releaseBranch: options.branch.release,
 		commitMessage: "chore: update release versions",
@@ -1857,7 +1813,7 @@ async function prepareWorkflow(options) {
 	if (!hasChangesToPush.ok) exitWithError(hasChangesToPush.error.message);
 	if (!hasChangesToPush.value) {
 		const prResult = await syncPullRequest({
-			github: githubOps,
+			github: options.githubClient,
 			releaseBranch: options.branch.release,
 			defaultBranch: options.branch.default,
 			pullRequestTitle: options.pullRequest?.title,
@@ -1877,7 +1833,7 @@ async function prepareWorkflow(options) {
 		return null;
 	}
 	const prResult = await syncPullRequest({
-		github: githubOps,
+		github: options.githubClient,
 		releaseBranch: options.branch.release,
 		defaultBranch: options.branch.default,
 		pullRequestTitle: options.pullRequest?.title,
@@ -1889,6 +1845,8 @@ async function prepareWorkflow(options) {
 		logger.section("🚀 Pull Request");
 		logger.success(`Pull request ${prResult.value.created ? "created" : "updated"}: ${prResult.value.pullRequest.html_url}`);
 	}
+	const returnToDefault = await checkoutBranch(options.branch.default, options.workspaceRoot);
+	if (!returnToDefault.ok || !returnToDefault.value) exitWithError(`Failed to checkout branch: ${options.branch.default}`);
 	return {
 		updates: allUpdates,
 		prUrl: prResult.value.pullRequest?.html_url,
@@ -1897,62 +1855,218 @@ async function prepareWorkflow(options) {
 }
 
 //#endregion
-//#region src/prepare.ts
-async function release(options) {
-	return prepareWorkflow(options);
+//#region src/core/npm.ts
+function toNPMError(operation, error, code) {
+	return {
+		type: "npm",
+		operation,
+		message: error instanceof Error ? error.message : String(error),
+		code
+	};
 }
-
-//#endregion
-//#region src/workflows/publish.ts
-async function publishWorkflow(options) {
-	logger.warn("Publish workflow is not implemented yet.");
-	logger.verbose("Publish options:", options);
+/**
+* Get the NPM registry URL
+* Respects NPM_CONFIG_REGISTRY environment variable, defaults to npmjs.org
+*/
+function getRegistryURL() {
+	return process.env.NPM_CONFIG_REGISTRY || "https://registry.npmjs.org";
 }
-
-//#endregion
-//#region src/publish.ts
-async function publish(options) {
-	return publishWorkflow(options);
+/**
+* Fetch package metadata from NPM registry
+* @param packageName - The package name (e.g., "lodash" or "@scope/name")
+* @returns Result with package metadata or error
+*/
+async function getPackageMetadata(packageName) {
+	try {
+		const registry = getRegistryURL();
+		const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
+		const response = await fetch(`${registry}/${encodedName}`, { headers: { Accept: "application/json" } });
+		if (!response.ok) {
+			if (response.status === 404) return err(toNPMError("getPackageMetadata", `Package not found: ${packageName}`, "E404"));
+			return err(toNPMError("getPackageMetadata", `HTTP ${response.status}: ${response.statusText}`));
+		}
+		return ok(await response.json());
+	} catch (error) {
+		return err(toNPMError("getPackageMetadata", error, "ENETWORK"));
+	}
+}
+/**
+* Check if a specific package version exists on NPM
+* @param packageName - The package name
+* @param version - The version to check (e.g., "1.2.3")
+* @returns Result with boolean (true if version exists) or error
+*/
+async function checkVersionExists(packageName, version) {
+	const metadataResult = await getPackageMetadata(packageName);
+	if (!metadataResult.ok) {
+		if (metadataResult.error.code === "E404") return ok(false);
+		return err(metadataResult.error);
+	}
+	return ok(version in metadataResult.value.versions);
+}
+/**
+* Build a package before publishing
+* @param packageName - The package name to build
+* @param workspaceRoot - Path to the workspace root
+* @param options - Normalized release scripts options
+* @returns Result indicating success or failure
+*/
+async function buildPackage(packageName, workspaceRoot, options) {
+	if (!options.npm.runBuild) return ok(void 0);
+	try {
+		await runIfNotDry("pnpm", [
+			"--filter",
+			packageName,
+			"build"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "inherit"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toNPMError("buildPackage", error));
+	}
+}
+/**
+* Publish a package to NPM
+* Uses pnpm to handle workspace protocol and catalog: resolution automatically
+* @param packageName - The package name to publish
+* @param workspaceRoot - Path to the workspace root
+* @param options - Normalized release scripts options
+* @returns Result indicating success or failure
+*/
+async function publishPackage(packageName, workspaceRoot, options) {
+	const args = [
+		"--filter",
+		packageName,
+		"publish",
+		"--access",
+		options.npm.access,
+		"--no-git-checks"
+	];
+	if (options.npm.otp) args.push("--otp", options.npm.otp);
+	if (process.env.NPM_CONFIG_TAG) args.push("--tag", process.env.NPM_CONFIG_TAG);
+	const env = { ...process.env };
+	if (options.npm.provenance) env.NPM_CONFIG_PROVENANCE = "true";
+	try {
+		await runIfNotDry("pnpm", args, { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "inherit",
+			env
+		} });
+		return ok(void 0);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return err(toNPMError("publishPackage", error, errorMessage.includes("E403") ? "E403" : errorMessage.includes("EPUBLISHCONFLICT") ? "EPUBLISHCONFLICT" : errorMessage.includes("EOTP") ? "EOTP" : void 0));
+	}
 }
 
 //#endregion
-//#region src/operations/discover.ts
-async function discoverPackages({ workspace, workspaceRoot, options }) {
-	return workspace.discoverWorkspacePackages(workspaceRoot, options);
+//#region src/workflows/publish.ts
+async function publishWorkflow(options) {
+	logger.section("📦 Publishing Packages");
+	const discovered = await discoverWorkspacePackages(options.workspaceRoot, options);
+	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
+	const workspacePackages = discovered.value;
+	logger.item(`Found ${workspacePackages.length} packages in workspace`);
+	const graph = buildPackageDependencyGraph(workspacePackages);
+	const publicPackages = workspacePackages.filter((pkg) => !pkg.packageJson.private);
+	logger.item(`Publishing ${publicPackages.length} public packages (private packages excluded)`);
+	if (publicPackages.length === 0) {
+		logger.warn("No public packages to publish");
+		return;
+	}
+	const publishOrder = getPackagePublishOrder(graph, new Set(publicPackages.map((p) => p.name)));
+	const status = {
+		published: [],
+		skipped: [],
+		failed: []
+	};
+	for (const order of publishOrder) {
+		const pkg = order.package;
+		const version = pkg.version;
+		const packageName = pkg.name;
+		logger.section(`📦 ${farver.cyan(packageName)} ${farver.gray(`(level ${order.level})`)}`);
+		logger.step(`Checking if ${farver.cyan(`${packageName}@${version}`)} exists on NPM...`);
+		const existsResult = await checkVersionExists(packageName, version);
+		if (!existsResult.ok) {
+			logger.error(`Failed to check version: ${existsResult.error.message}`);
+			status.failed.push(packageName);
+			exitWithError(`Publishing failed for ${packageName}: ${existsResult.error.message}`, "Check your network connection and NPM registry access");
+		}
+		if (existsResult.value) {
+			logger.info(`Version ${farver.cyan(version)} already exists on NPM, skipping`);
+			status.skipped.push(packageName);
+			continue;
+		}
+		if (options.npm.runBuild) {
+			logger.step(`Building ${farver.cyan(packageName)}...`);
+			const buildResult = await buildPackage(packageName, options.workspaceRoot, options);
+			if (!buildResult.ok) {
+				logger.error(`Failed to build package: ${buildResult.error.message}`);
+				status.failed.push(packageName);
+				exitWithError(`Publishing failed for ${packageName}: build failed`, "Check your build scripts and dependencies");
+			}
+		}
+		logger.step(`Publishing ${farver.cyan(`${packageName}@${version}`)} to NPM...`);
+		const publishResult = await publishPackage(packageName, options.workspaceRoot, options);
+		if (!publishResult.ok) {
+			logger.error(`Failed to publish: ${publishResult.error.message}`);
+			status.failed.push(packageName);
+			let hint;
+			if (publishResult.error.code === "E403") hint = "Authentication failed. Ensure your NPM token or OIDC configuration is correct";
+			else if (publishResult.error.code === "EPUBLISHCONFLICT") hint = "Version conflict. The version may have been published recently";
+			else if (publishResult.error.code === "EOTP") hint = "2FA/OTP required. Provide the otp option or use OIDC authentication";
+			exitWithError(`Publishing failed for ${packageName}`, hint);
+		}
+		logger.success(`Published ${farver.cyan(`${packageName}@${version}`)}`);
+		status.published.push(packageName);
+		logger.step(`Creating git tag ${farver.cyan(`${packageName}@${version}`)}...`);
+		const tagResult = await createAndPushPackageTag(packageName, version, options.workspaceRoot);
+		if (!tagResult.ok) {
+			logger.error(`Failed to create/push tag: ${tagResult.error.message}`);
+			logger.warn(`Package was published but tag was not created. You may need to create it manually.`);
+		} else logger.success(`Created and pushed tag ${farver.cyan(`${packageName}@${version}`)}`);
+	}
+	logger.section("📊 Publishing Summary");
+	logger.item(`${farver.green("✓")} Published: ${status.published.length} package(s)`);
+	if (status.published.length > 0) for (const pkg of status.published) logger.item(`  ${farver.green("•")} ${pkg}`);
+	if (status.skipped.length > 0) {
+		logger.item(`${farver.yellow("⚠")} Skipped (already exists): ${status.skipped.length} package(s)`);
+		for (const pkg of status.skipped) logger.item(`  ${farver.yellow("•")} ${pkg}`);
+	}
+	if (status.failed.length > 0) {
+		logger.item(`${farver.red("✖")} Failed: ${status.failed.length} package(s)`);
+		for (const pkg of status.failed) logger.item(`  ${farver.red("•")} ${pkg}`);
+	}
+	if (status.failed.length > 0) exitWithError(`Publishing completed with ${status.failed.length} failure(s)`);
+	logger.success("All packages published successfully!");
 }
 
 //#endregion
 //#region src/workflows/verify.ts
 async function verifyWorkflow(options) {
-	const gitOps = createGitOperations();
-	const githubOps = createGitHubOperations({
-		owner: options.owner,
-		repo: options.repo,
-		githubToken: options.githubToken
-	});
-	const workspaceOps = createWorkspaceOperations();
 	if (options.safeguards) {
-		const clean = await gitOps.isWorkingDirectoryClean(options.workspaceRoot);
+		const clean = await isWorkingDirectoryClean(options.workspaceRoot);
 		if (!clean.ok || !clean.value) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
 	}
 	const releaseBranch = options.branch.release;
 	const defaultBranch = options.branch.default;
-	const releasePr = await githubOps.getExistingPullRequest(releaseBranch);
-	if (!releasePr.ok) exitWithError(releasePr.error.message);
-	if (!releasePr.value || !releasePr.value.head) {
+	const releasePr = await options.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.value.number}. Verifying against default branch "${defaultBranch}"...`);
-	const originalBranch = await gitOps.getCurrentBranch(options.workspaceRoot);
+	logger.info(`Found release PR #${releasePr.number}. Verifying against default branch "${defaultBranch}"...`);
+	const originalBranch = await getCurrentBranch(options.workspaceRoot);
 	if (!originalBranch.ok) exitWithError(originalBranch.error.message);
 	if (originalBranch.value !== defaultBranch) {
-		const checkout = await gitOps.checkoutBranch(defaultBranch, options.workspaceRoot);
+		const checkout = await checkoutBranch(defaultBranch, options.workspaceRoot);
 		if (!checkout.ok || !checkout.value) exitWithError(`Failed to checkout branch: ${defaultBranch}`);
 	}
 	let existingOverrides = {};
 	try {
-		const overridesContent = await gitOps.readFileFromGit(options.workspaceRoot, releasePr.value.head.sha, ucdjsReleaseOverridesPath);
+		const overridesContent = await readFileFromGit(options.workspaceRoot, releasePr.head.sha, ucdjsReleaseOverridesPath);
 		if (overridesContent.ok && overridesContent.value) {
 			existingOverrides = JSON.parse(overridesContent.value);
 			logger.info("Found existing version overrides file on release branch.");
@@ -1960,11 +2074,7 @@ async function verifyWorkflow(options) {
 	} catch {
 		logger.info("No version overrides file found on release branch. Continuing...");
 	}
-	const discovered = await discoverPackages({
-		workspace: workspaceOps,
-		workspaceRoot: options.workspaceRoot,
-		options
-	});
+	const discovered = await discoverWorkspacePackages(options.workspaceRoot, options);
 	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
 	const ensured = ensureHasPackages(discovered.value);
 	if (!ensured.ok) {
@@ -1973,7 +2083,6 @@ async function verifyWorkflow(options) {
 	}
 	const mainPackages = ensured.value;
 	const updatesResult = await calculateUpdates({
-		versioning: createVersioningOperations(),
 		workspacePackages: mainPackages,
 		workspaceRoot: options.workspaceRoot,
 		showPrompt: false,
@@ -1986,13 +2095,13 @@ async function verifyWorkflow(options) {
 	const prVersionMap = /* @__PURE__ */ new Map();
 	for (const pkg of mainPackages) {
 		const pkgJsonPath = relative(options.workspaceRoot, join(pkg.path, "package.json"));
-		const pkgJsonContent = await gitOps.readFileFromGit(options.workspaceRoot, releasePr.value.head.sha, pkgJsonPath);
+		const pkgJsonContent = await readFileFromGit(options.workspaceRoot, releasePr.head.sha, pkgJsonPath);
 		if (pkgJsonContent.ok && pkgJsonContent.value) {
 			const pkgJson = JSON.parse(pkgJsonContent.value);
 			prVersionMap.set(pkg.name, pkgJson.version);
 		}
 	}
-	if (originalBranch.value !== defaultBranch) await gitOps.checkoutBranch(originalBranch.value, options.workspaceRoot);
+	if (originalBranch.value !== defaultBranch) await checkoutBranch(originalBranch.value, options.workspaceRoot);
 	let isOutOfSync = false;
 	for (const [pkgName, expectedVersion] of expectedVersionMap.entries()) {
 		const prVersion = prVersionMap.get(pkgName);
@@ -2007,51 +2116,49 @@ async function verifyWorkflow(options) {
 	}
 	const statusContext = "ucdjs/release-verify";
 	if (isOutOfSync) {
-		await githubOps.setCommitStatus({
-			sha: releasePr.value.head.sha,
+		await options.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 githubOps.setCommitStatus({
-			sha: releasePr.value.head.sha,
+		await options.githubClient.setCommitStatus({
+			sha: releasePr.head.sha,
 			state: "success",
 			context: statusContext,
 			description: "Release PR is up to date.",
-			targetUrl: `https://github.com/${options.owner}/${options.repo}/pull/${releasePr.value.number}`
+			targetUrl: `https://github.com/${options.owner}/${options.repo}/pull/${releasePr.number}`
 		});
 		logger.success("Verification successful. Commit status set to 'success'.");
 	}
 }
 
-//#endregion
-//#region src/verify.ts
-async function verify(options) {
-	return verifyWorkflow(options);
-}
-
 //#endregion
 //#region src/index.ts
 async function createReleaseScripts(options) {
 	const normalizedOptions = normalizeReleaseScriptsOptions(options);
 	return {
 		async verify() {
-			return verify(normalizedOptions);
+			return verifyWorkflow(normalizedOptions);
 		},
 		async prepare() {
-			return release(normalizedOptions);
+			return prepareWorkflow(normalizedOptions);
 		},
 		async publish() {
-			return publish(normalizedOptions);
+			return publishWorkflow(normalizedOptions);
 		},
 		packages: {
 			async list() {
-				return discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions);
+				const result = await discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions);
+				if (!result.ok) throw new Error(result.error.message);
+				return result.value;
 			},
 			async get(packageName) {
-				return (await discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions)).find((p) => p.name === packageName);
+				const result = await discoverWorkspacePackages(normalizedOptions.workspaceRoot, normalizedOptions);
+				if (!result.ok) throw new Error(result.error.message);
+				return result.value.find((p) => p.name === packageName);
 			}
 		}
 	};