@ucdjs/release-scripts 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/eta-Boh7yPZi.mjs

@@ -0,0 +1,477 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+//#region node_modules/.pnpm/eta@4.0.1/node_modules/eta/dist/index.js
+var EtaError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "Eta Error";
+	}
+};
+var EtaParseError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaParser Error";
+	}
+};
+var EtaRuntimeError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaRuntime Error";
+	}
+};
+var EtaFileResolutionError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaFileResolution Error";
+	}
+};
+var EtaNameResolutionError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaNameResolution Error";
+	}
+};
+/**
+* Throws an EtaError with a nicely formatted error and message showing where in the template the error occurred.
+*/
+function ParseErr(message, str, indx) {
+	const whitespace = str.slice(0, indx).split(/\n/);
+	const lineNo = whitespace.length;
+	const colNo = whitespace[lineNo - 1].length + 1;
+	message += " at line " + lineNo + " col " + colNo + ":\n\n  " + str.split(/\n/)[lineNo - 1] + "\n  " + Array(colNo).join(" ") + "^";
+	throw new EtaParseError(message);
+}
+function RuntimeErr(originalError, str, lineNo, path$1) {
+	const lines = str.split("\n");
+	const start = Math.max(lineNo - 3, 0);
+	const end = Math.min(lines.length, lineNo + 3);
+	const filename = path$1;
+	const context = lines.slice(start, end).map((line, i) => {
+		const curr = i + start + 1;
+		return (curr === lineNo ? " >> " : "    ") + curr + "| " + line;
+	}).join("\n");
+	const err = new EtaRuntimeError((filename ? filename + ":" + lineNo + "\n" : "line " + lineNo + "\n") + context + "\n\n" + originalError.message);
+	err.name = originalError.name;
+	throw err;
+}
+function readFile(path$1) {
+	let res = "";
+	try {
+		res = fs.readFileSync(path$1, "utf8");
+	} catch (err) {
+		if (err?.code === "ENOENT") throw new EtaFileResolutionError(`Could not find template: ${path$1}`);
+		else throw err;
+	}
+	return res;
+}
+function resolvePath(templatePath, options) {
+	let resolvedFilePath = "";
+	const views = this.config.views;
+	if (!views) throw new EtaFileResolutionError("Views directory is not defined");
+	const baseFilePath = options?.filepath;
+	const defaultExtension = this.config.defaultExtension === void 0 ? ".eta" : this.config.defaultExtension;
+	const cacheIndex = JSON.stringify({
+		filename: baseFilePath,
+		path: templatePath,
+		views: this.config.views
+	});
+	templatePath += path.extname(templatePath) ? "" : defaultExtension;
+	if (baseFilePath) {
+		if (this.config.cacheFilepaths && this.filepathCache[cacheIndex]) return this.filepathCache[cacheIndex];
+		if (absolutePathRegExp.exec(templatePath)?.length) {
+			const formattedPath = templatePath.replace(/^\/*|^\\*/, "");
+			resolvedFilePath = path.join(views, formattedPath);
+		} else resolvedFilePath = path.join(path.dirname(baseFilePath), templatePath);
+	} else resolvedFilePath = path.join(views, templatePath);
+	if (dirIsChild(views, resolvedFilePath)) {
+		if (baseFilePath && this.config.cacheFilepaths) this.filepathCache[cacheIndex] = resolvedFilePath;
+		return resolvedFilePath;
+	} else throw new EtaFileResolutionError(`Template '${templatePath}' is not in the views directory`);
+}
+function dirIsChild(parent, dir) {
+	const relative = path.relative(parent, dir);
+	return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+const absolutePathRegExp = /^\\|^\//;
+/* istanbul ignore next */
+const AsyncFunction = (async () => {}).constructor;
+/**
+* Takes a template string and returns a template function that can be called with (data, config)
+*
+* @param str - The template string
+* @param config - A custom configuration object (optional)
+*/
+function compile(str, options) {
+	const config = this.config;
+	const ctor = options?.async ? AsyncFunction : Function;
+	try {
+		return new ctor(config.varName, "options", this.compileToString.call(this, str, options));
+	} catch (e) {
+		if (e instanceof SyntaxError) throw new EtaParseError("Bad template syntax\n\n" + e.message + "\n" + Array(e.message.length + 1).join("=") + "\n" + this.compileToString.call(this, str, options) + "\n");
+		else throw e;
+	}
+}
+/**
+* Compiles a template string to a function string. Most often users just use `compile()`, which calls `compileToString` and creates a new function using the result
+*/
+function compileToString(str, options) {
+	const config = this.config;
+	const isAsync = options?.async;
+	const compileBody$1 = this.compileBody;
+	const buffer = this.parse.call(this, str);
+	let res = `${config.functionHeader}
+let include = (template, data) => this.render(template, data, options);
+let includeAsync = (template, data) => this.renderAsync(template, data, options);
+
+let __eta = {res: "", e: this.config.escapeFunction, f: this.config.filterFunction${config.debug ? ", line: 1, templateStr: \"" + str.replace(/\\|"/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n") + "\"" : ""}};
+
+function layout(path, data) {
+  __eta.layout = path;
+  __eta.layoutData = data;
+}${config.debug ? "try {" : ""}${config.useWith ? "with(" + config.varName + "||{}){" : ""}
+
+${compileBody$1.call(this, buffer)}
+if (__eta.layout) {
+  __eta.res = ${isAsync ? "await includeAsync" : "include"} (__eta.layout, {...${config.varName}, body: __eta.res, ...__eta.layoutData});
+}
+${config.useWith ? "}" : ""}${config.debug ? "} catch (e) { this.RuntimeErr(e, __eta.templateStr, __eta.line, options.filepath) }" : ""}
+return __eta.res;
+`;
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processFnString) res = plugin.processFnString(res, config);
+	}
+	return res;
+}
+/**
+* Loops through the AST generated by `parse` and transform each item into JS calls
+*
+* **Example**
+*
+* ```js
+* let templateAST = ['Hi ', { val: 'it.name', t: 'i' }]
+* compileBody.call(Eta, templateAST)
+* // => "__eta.res+='Hi '\n__eta.res+=__eta.e(it.name)\n"
+* ```
+*/
+function compileBody(buff) {
+	const config = this.config;
+	let i = 0;
+	const buffLength = buff.length;
+	let returnStr = "";
+	for (; i < buffLength; i++) {
+		const currentBlock = buff[i];
+		if (typeof currentBlock === "string") returnStr += "__eta.res+='" + currentBlock + "'\n";
+		else {
+			const type = currentBlock.t;
+			let content = currentBlock.val || "";
+			if (config.debug) returnStr += "__eta.line=" + currentBlock.lineNo + "\n";
+			if (type === "r") {
+				if (config.autoFilter) content = "__eta.f(" + content + ")";
+				returnStr += "__eta.res+=" + content + "\n";
+			} else if (type === "i") {
+				if (config.autoFilter) content = "__eta.f(" + content + ")";
+				if (config.autoEscape) content = "__eta.e(" + content + ")";
+				returnStr += "__eta.res+=" + content + "\n";
+			} else if (type === "e") returnStr += content + "\n";
+		}
+	}
+	return returnStr;
+}
+/**
+* Takes a string within a template and trims it, based on the preceding tag's whitespace control and `config.autoTrim`
+*/
+function trimWS(str, config, wsLeft, wsRight) {
+	let leftTrim;
+	let rightTrim;
+	if (Array.isArray(config.autoTrim)) {
+		leftTrim = config.autoTrim[1];
+		rightTrim = config.autoTrim[0];
+	} else leftTrim = rightTrim = config.autoTrim;
+	if (wsLeft || wsLeft === false) leftTrim = wsLeft;
+	if (wsRight || wsRight === false) rightTrim = wsRight;
+	if (!rightTrim && !leftTrim) return str;
+	if (leftTrim === "slurp" && rightTrim === "slurp") return str.trim();
+	if (leftTrim === "_" || leftTrim === "slurp") str = str.trimStart();
+	else if (leftTrim === "-" || leftTrim === "nl") str = str.replace(/^(?:\r\n|\n|\r)/, "");
+	if (rightTrim === "_" || rightTrim === "slurp") str = str.trimEnd();
+	else if (rightTrim === "-" || rightTrim === "nl") str = str.replace(/(?:\r\n|\n|\r)$/, "");
+	return str;
+}
+/**
+* A map of special HTML characters to their XML-escaped equivalents
+*/
+const escMap = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function replaceChar(s) {
+	return escMap[s];
+}
+/**
+* XML-escapes an input value after converting it to a string
+*
+* @param str - Input value (usually a string)
+* @returns XML-escaped string
+*/
+function XMLEscape(str) {
+	const newStr = String(str);
+	if (/[&<>"']/.test(newStr)) return newStr.replace(/[&<>"']/g, replaceChar);
+	else return newStr;
+}
+/** Eta's base (global) configuration */
+const defaultConfig = {
+	autoEscape: true,
+	autoFilter: false,
+	autoTrim: [false, "nl"],
+	cache: false,
+	cacheFilepaths: true,
+	debug: false,
+	escapeFunction: XMLEscape,
+	filterFunction: (val) => String(val),
+	functionHeader: "",
+	parse: {
+		exec: "",
+		interpolate: "=",
+		raw: "~"
+	},
+	plugins: [],
+	rmWhitespace: false,
+	tags: ["<%", "%>"],
+	useWith: false,
+	varName: "it",
+	defaultExtension: ".eta"
+};
+const templateLitReg = /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g;
+const singleQuoteReg = /'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g;
+const doubleQuoteReg = /"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g;
+/** Escape special regular expression characters inside a string */
+function escapeRegExp(string) {
+	return string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+}
+function getLineNo(str, index) {
+	return str.slice(0, index).split("\n").length;
+}
+function parse(str) {
+	const config = this.config;
+	let buffer = [];
+	let trimLeftOfNextStr = false;
+	let lastIndex = 0;
+	const parseOptions = config.parse;
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processTemplate) str = plugin.processTemplate(str, config);
+	}
+	if (config.rmWhitespace) str = str.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+	templateLitReg.lastIndex = 0;
+	singleQuoteReg.lastIndex = 0;
+	doubleQuoteReg.lastIndex = 0;
+	function pushString(strng, shouldTrimRightOfString) {
+		if (strng) {
+			strng = trimWS(strng, config, trimLeftOfNextStr, shouldTrimRightOfString);
+			if (strng) {
+				strng = strng.replace(/\\|'/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n");
+				buffer.push(strng);
+			}
+		}
+	}
+	const prefixes = [
+		parseOptions.exec,
+		parseOptions.interpolate,
+		parseOptions.raw
+	].reduce((accumulator, prefix) => {
+		if (accumulator && prefix) return accumulator + "|" + escapeRegExp(prefix);
+		else if (prefix) return escapeRegExp(prefix);
+		else return accumulator;
+	}, "");
+	const parseOpenReg = new RegExp(escapeRegExp(config.tags[0]) + "(-|_)?\\s*(" + prefixes + ")?\\s*", "g");
+	const parseCloseReg = new RegExp("'|\"|`|\\/\\*|(\\s*(-|_)?" + escapeRegExp(config.tags[1]) + ")", "g");
+	let m;
+	while (m = parseOpenReg.exec(str)) {
+		const precedingString = str.slice(lastIndex, m.index);
+		lastIndex = m[0].length + m.index;
+		const wsLeft = m[1];
+		const prefix = m[2] || "";
+		pushString(precedingString, wsLeft);
+		parseCloseReg.lastIndex = lastIndex;
+		let closeTag;
+		let currentObj = false;
+		while (closeTag = parseCloseReg.exec(str)) if (closeTag[1]) {
+			const content = str.slice(lastIndex, closeTag.index);
+			parseOpenReg.lastIndex = lastIndex = parseCloseReg.lastIndex;
+			trimLeftOfNextStr = closeTag[2];
+			currentObj = {
+				t: prefix === parseOptions.exec ? "e" : prefix === parseOptions.raw ? "r" : prefix === parseOptions.interpolate ? "i" : "",
+				val: content
+			};
+			break;
+		} else {
+			const char = closeTag[0];
+			if (char === "/*") {
+				const commentCloseInd = str.indexOf("*/", parseCloseReg.lastIndex);
+				if (commentCloseInd === -1) ParseErr("unclosed comment", str, closeTag.index);
+				parseCloseReg.lastIndex = commentCloseInd;
+			} else if (char === "'") {
+				singleQuoteReg.lastIndex = closeTag.index;
+				if (singleQuoteReg.exec(str)) parseCloseReg.lastIndex = singleQuoteReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			} else if (char === "\"") {
+				doubleQuoteReg.lastIndex = closeTag.index;
+				if (doubleQuoteReg.exec(str)) parseCloseReg.lastIndex = doubleQuoteReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			} else if (char === "`") {
+				templateLitReg.lastIndex = closeTag.index;
+				if (templateLitReg.exec(str)) parseCloseReg.lastIndex = templateLitReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			}
+		}
+		if (currentObj) {
+			if (config.debug) currentObj.lineNo = getLineNo(str, m.index);
+			buffer.push(currentObj);
+		} else ParseErr("unclosed tag", str, m.index);
+	}
+	pushString(str.slice(lastIndex, str.length), false);
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processAST) buffer = plugin.processAST(buffer, config);
+	}
+	return buffer;
+}
+function handleCache(template, options) {
+	const templateStore = options?.async ? this.templatesAsync : this.templatesSync;
+	if (this.resolvePath && this.readFile && !template.startsWith("@")) {
+		const templatePath = options.filepath;
+		const cachedTemplate = templateStore.get(templatePath);
+		if (this.config.cache && cachedTemplate) return cachedTemplate;
+		else {
+			const templateString = this.readFile(templatePath);
+			const templateFn = this.compile(templateString, options);
+			if (this.config.cache) templateStore.define(templatePath, templateFn);
+			return templateFn;
+		}
+	} else {
+		const cachedTemplate = templateStore.get(template);
+		if (cachedTemplate) return cachedTemplate;
+		else throw new EtaNameResolutionError(`Failed to get template '${template}'`);
+	}
+}
+function render(template, data, meta) {
+	let templateFn;
+	const options = {
+		...meta,
+		async: false
+	};
+	if (typeof template === "string") {
+		if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+		templateFn = handleCache.call(this, template, options);
+	} else templateFn = template;
+	return templateFn.call(this, data, options);
+}
+function renderAsync(template, data, meta) {
+	let templateFn;
+	const options = {
+		...meta,
+		async: true
+	};
+	if (typeof template === "string") {
+		if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+		templateFn = handleCache.call(this, template, options);
+	} else templateFn = template;
+	const res = templateFn.call(this, data, options);
+	return Promise.resolve(res);
+}
+function renderString(template, data) {
+	const templateFn = this.compile(template, { async: false });
+	return render.call(this, templateFn, data);
+}
+function renderStringAsync(template, data) {
+	const templateFn = this.compile(template, { async: true });
+	return renderAsync.call(this, templateFn, data);
+}
+/**
+* Handles storage and accessing of values
+*
+* In this case, we use it to store compiled template functions
+* Indexed by their `name` or `filename`
+*/
+var Cacher = class {
+	constructor(cache) {
+		this.cache = cache;
+	}
+	define(key, val) {
+		this.cache[key] = val;
+	}
+	get(key) {
+		return this.cache[key];
+	}
+	remove(key) {
+		delete this.cache[key];
+	}
+	reset() {
+		this.cache = {};
+	}
+	load(cacheObj) {
+		this.cache = {
+			...this.cache,
+			...cacheObj
+		};
+	}
+};
+var Eta$1 = class {
+	constructor(customConfig) {
+		if (customConfig) this.config = {
+			...defaultConfig,
+			...customConfig
+		};
+		else this.config = { ...defaultConfig };
+	}
+	config;
+	RuntimeErr = RuntimeErr;
+	compile = compile;
+	compileToString = compileToString;
+	compileBody = compileBody;
+	parse = parse;
+	render = render;
+	renderAsync = renderAsync;
+	renderString = renderString;
+	renderStringAsync = renderStringAsync;
+	filepathCache = {};
+	templatesSync = new Cacher({});
+	templatesAsync = new Cacher({});
+	resolvePath = null;
+	readFile = null;
+	configure(customConfig) {
+		this.config = {
+			...this.config,
+			...customConfig
+		};
+	}
+	withConfig(customConfig) {
+		return {
+			...this,
+			config: {
+				...this.config,
+				...customConfig
+			}
+		};
+	}
+	loadTemplate(name, template, options) {
+		if (typeof template === "string") (options?.async ? this.templatesAsync : this.templatesSync).define(name, this.compile(template, options));
+		else {
+			let templates = this.templatesSync;
+			if (template.constructor.name === "AsyncFunction" || options?.async) templates = this.templatesAsync;
+			templates.define(name, template);
+		}
+	}
+};
+var Eta = class extends Eta$1 {
+	readFile = readFile;
+	resolvePath = resolvePath;
+};
+
+//#endregion
+export { Eta as t };

package/dist/index.d.mts

@@ -10,6 +10,45 @@ interface WorkspacePackage {
 //#endregion
 //#region src/types.d.ts
 type BumpKind = "none" | "patch" | "minor" | "major";
+interface SharedOptions {
+  /**
+   * Repository identifier (e.g., "owner/repo")
+   */
+  repo: string;
+  /**
+   * Root directory of the workspace (defaults to process.cwd())
+   */
+  workspaceRoot?: string;
+  /**
+   * Specific packages to prepare for release.
+   * - true: discover all packages
+   * - FindWorkspacePackagesOptions: discover with filters
+   * - string[]: specific package names
+   */
+  packages?: true | FindWorkspacePackagesOptions | string[];
+  /**
+   * Whether to enable verbose logging
+   * @default false
+   */
+  verbose?: boolean;
+  /**
+   * GitHub token for authentication
+   */
+  githubToken: string;
+  /**
+   * Interactive prompt configuration
+   */
+  prompts?: {
+    /**
+     * Enable package selection prompt (defaults to true when not in CI)
+     */
+    packages?: boolean;
+    /**
+     * Enable version override prompt (defaults to true when not in CI)
+     */
+    versions?: boolean;
+  };
+}
 interface PackageJson {
   name: string;
   version: string;
@@ -23,11 +62,11 @@ interface FindWorkspacePackagesOptions {
   /**
    * Package names to exclude
    */
-  excluded?: string[];
+  exclude?: string[];
   /**
    * Only include these packages (if specified, all others are excluded)
    */
-  included?: string[];
+  include?: string[];
   /**
    * Whether to exclude private packages (default: false)
    */
@@ -55,39 +94,17 @@ interface VersionUpdate {
    */
   hasDirectChanges: boolean;
 }
-interface ReleaseOptions {
-  /**
-   * Repository identifier (e.g., "owner/repo")
-   */
-  repo: string;
-  /**
-   * Root directory of the workspace (defaults to process.cwd())
-   */
-  workspaceRoot?: string;
-  /**
-   * Specific packages to prepare for release.
-   * - true: discover all packages
-   * - FindWorkspacePackagesOptions: discover with filters
-   * - string[]: specific package names
-   */
-  packages?: true | FindWorkspacePackagesOptions | string[];
+//#endregion
+//#region src/publish.d.ts
+interface PublishOptions extends SharedOptions {}
+declare function publish(_options: PublishOptions): void;
+//#endregion
+//#region src/release.d.ts
+interface ReleaseOptions extends SharedOptions {
   /**
    * Branch name for the release PR (defaults to "release/next")
    */
   releaseBranch?: string;
-  /**
-   * Interactive prompt configuration
-   */
-  prompts?: {
-    /**
-     * Enable package selection prompt (defaults to true when not in CI)
-     */
-    packages?: boolean;
-    /**
-     * Enable version override prompt (defaults to true when not in CI)
-     */
-    versions?: boolean;
-  };
   /**
    * Whether to perform a dry run (no changes pushed or PR created)
    * @default false
@@ -99,9 +116,8 @@ interface ReleaseOptions {
    */
   safeguards?: boolean;
   /**
-   * GitHub token for authentication
+   * Pull request configuration
    */
-  githubToken: string;
   pullRequest?: {
     /**
      * Title for the release pull request
@@ -132,8 +148,6 @@ interface ReleaseResult {
    */
   created: boolean;
 }
-//#endregion
-//#region src/release.d.ts
 declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
 //#endregion
-export { release };
+export { type PublishOptions, type ReleaseOptions, type ReleaseResult, publish, release };

package/dist/index.mjs

@@ -1,16 +1,41 @@
-import process from "node:process";
+import { t as Eta } from "./eta-Boh7yPZi.mjs";
 import { getCommits } from "commit-parser";
+import process from "node:process";
 import farver from "farver";
 import { exec } from "tinyexec";
 import { dedent } from "@luxass/utils";
-import { Eta } from "eta";
-import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
 import prompts from "prompts";
 
+//#region src/publish.ts
+function publish(_options) {}
+
+//#endregion
 //#region src/utils.ts
-const globalOptions = { dryRun: false };
+const globalOptions = {
+	dryRun: false,
+	verbose: false
+};
 const isCI = typeof process.env.CI === "string" && process.env.CI !== "" && process.env.CI.toLowerCase() !== "false";
+const logger = {
+	info: (...args) => {
+		console.info(farver.cyan("[info]:"), ...args);
+	},
+	debug: (...args) => {
+		console.debug(farver.gray("[debug]:"), ...args);
+	},
+	warn: (...args) => {
+		console.warn(farver.yellow("[warn]:"), ...args);
+	},
+	error: (...args) => {
+		console.error(farver.red("[error]:"), ...args);
+	},
+	log: (...args) => {
+		if (!globalOptions.verbose) return;
+		console.log(...args);
+	}
+};
 async function run(bin, args, opts = {}) {
 	return exec(bin, args, {
 		throwOnError: true,
@@ -22,18 +47,49 @@ async function run(bin, args, opts = {}) {
 	});
 }
 async function dryRun(bin, args, opts) {
-	return console.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
+	return logger.log(farver.blue(`[dryrun] ${bin} ${args.join(" ")}`), opts || "");
 }
 const runIfNotDry = globalOptions.dryRun ? dryRun : run;
+function exitWithError(message, hint) {
+	logger.error(farver.bold(message));
+	if (hint) console.error(farver.gray(`  ${hint}`));
+	process.exit(1);
+}
+function normalizeSharedOptions(options) {
+	const { workspaceRoot = process.cwd(), githubToken = "", verbose = false, repo, packages = true, prompts: prompts$1 = {
+		packages: true,
+		versions: true
+	},...rest } = options;
+	globalOptions.verbose = verbose;
+	if (!githubToken.trim()) exitWithError("GitHub token is required", "Set GITHUB_TOKEN environment variable or pass it in options");
+	if (!repo || !repo.trim() || !repo.includes("/")) exitWithError("Repository (repo) is required", "Specify the repository in 'owner/repo' format (e.g., 'octocat/hello-world')");
+	const [owner, name] = options.repo.split("/");
+	if (!owner || !name) exitWithError(`Invalid repo format: "${options.repo}"`, "Expected format: \"owner/repo\" (e.g., \"octocat/hello-world\")");
+	return {
+		...rest,
+		packages,
+		prompts: prompts$1,
+		workspaceRoot,
+		githubToken,
+		owner,
+		repo,
+		verbose
+	};
+}
 
 //#endregion
 //#region src/commits.ts
 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}@`));
+	try {
+		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}@`));
+	} catch (err) {
+		logger.warn(`Failed to get tags for package ${packageName}: ${err.message}`);
+		return;
+	}
 }
 function determineHighestBump(commits) {
 	if (commits.length === 0) return "none";
@@ -46,35 +102,42 @@ function determineHighestBump(commits) {
 	}
 	return highestBump;
 }
-async function getPackageCommits(pkg, workspaceRoot) {
+/**
+* Retrieves commits that affect a specific workspace package since its last tag.
+*
+* @param {string} workspaceRoot - The root directory of the workspace.
+* @param {WorkspacePackage} pkg - The workspace package to analyze.
+* @returns {Promise<GitCommit[]>} A promise that resolves to an array of GitCommit objects affecting the package.
+*/
+async function getCommitsForWorkspacePackage(workspaceRoot, pkg) {
 	const lastTag = await getLastPackageTag(pkg.name, workspaceRoot);
 	const allCommits = getCommits({
 		from: lastTag,
-		to: "HEAD"
+		to: "HEAD",
+		cwd: workspaceRoot
+	});
+	logger.log(`Found ${allCommits.length} commits for ${pkg.name} since ${lastTag || "beginning"}`);
+	const touchedCommitHashes = getCommits({
+		from: lastTag,
+		to: "HEAD",
+		cwd: workspaceRoot,
+		folder: pkg.path
 	});
-	console.log(`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));
-	console.log(`${packageCommits.length} commits affect ${pkg.name}`);
+	const packageCommits = allCommits.filter((commit) => touchedSet.has(commit));
+	logger.log(`${packageCommits.length} commits affect ${pkg.name}`);
 	return packageCommits;
 }
-async function analyzePackageCommits(pkg, workspaceRoot) {
-	return determineHighestBump(await getPackageCommits(pkg, workspaceRoot));
-}
-/**
-* Analyze commits for multiple packages to determine version bumps
-*
-* @param packages - Packages to analyze
-* @param workspaceRoot - Root directory of the workspace
-* @returns Map of package names to their bump types
-*/
-async function analyzeCommits(packages, workspaceRoot) {
+async function getWorkspacePackageCommits(workspaceRoot, packages) {
 	const changedPackages = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const bump = await analyzePackageCommits(pkg, workspaceRoot);
-		if (bump !== "none") changedPackages.set(pkg.name, bump);
-	}
+	const promises = packages.map(async (pkg) => {
+		return {
+			pkgName: pkg.name,
+			commits: await getCommitsForWorkspacePackage(workspaceRoot, pkg)
+		};
+	});
+	const results = await Promise.all(promises);
+	for (const { pkgName, commits } of results) changedPackages.set(pkgName, commits);
 	return changedPackages;
 }
 function determineBumpType(commit) {
@@ -95,24 +158,6 @@ function determineBumpType(commit) {
 		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) {
-		console.error(`Error getting commits touching package: ${error}`);
-		return [];
-	}
-}
 
 //#endregion
 //#region src/git.ts
@@ -129,7 +174,7 @@ async function isWorkingDirectoryClean(workspaceRoot) {
 		} })).stdout.trim() !== "") return false;
 		return true;
 	} catch (err) {
-		console.error("Error checking git status:", err);
+		logger.error("Error checking git status:", err);
 		return false;
 	}
 }
@@ -313,10 +358,10 @@ async function getExistingPullRequest({ owner, repo, branch, githubToken }) {
 			draft: firstPullRequest.draft,
 			html_url: firstPullRequest.html_url
 		};
-		console.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
+		logger.info(`Found existing pull request: ${farver.yellow(`#${pullRequest.number}`)}`);
 		return pullRequest;
 	} catch (err) {
-		console.error("Error fetching pull request:", err);
+		logger.error("Error fetching pull request:", err);
 		return null;
 	}
 }
@@ -346,7 +391,7 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 		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}`)}`);
+		logger.info(`${action} pull request: ${farver.yellow(`#${pr.number}`)}`);
 		return {
 			number: pr.number,
 			title: pr.title,
@@ -355,7 +400,7 @@ async function upsertPullRequest({ owner, repo, title, body, head, base, pullNum
 			html_url: pr.html_url
 		};
 	} catch (err) {
-		console.error(`Error upserting pull request:`, err);
+		logger.error(`Error upserting pull request:`, err);
 		throw err;
 	}
 }
@@ -392,6 +437,65 @@ function generatePullRequestBody(updates, body) {
 	})) });
 }
 
+//#endregion
+//#region src/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 promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
+	const choices = [{
+		title: `Use suggested: ${suggestedVersion} (${suggestedBumpType})`,
+		value: "suggested"
+	}];
+	for (const bumpType of [
+		"patch",
+		"minor",
+		"major"
+	]) if (bumpType !== suggestedBumpType) {
+		const version = getNextVersion(currentVersion, bumpType);
+		choices.push({
+			title: `${bumpType}: ${version}`,
+			value: bumpType
+		});
+	}
+	choices.push({
+		title: "Custom version",
+		value: "custom"
+	});
+	const response = await prompts([{
+		type: "select",
+		name: "choice",
+		message: `${pkg.name} (${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 getNextVersion(currentVersion, response.choice);
+}
+
 //#endregion
 //#region src/version.ts
 function isValidSemver(version) {
@@ -400,11 +504,7 @@ function isValidSemver(version) {
 function validateSemver(version) {
 	if (!isValidSemver(version)) throw new Error(`Invalid semver version: ${version}`);
 }
-/**
-* Calculate the new version based on current version and bump type
-* Pure function - no side effects, easily testable
-*/
-function calculateNewVersion(currentVersion, bump) {
+function getNextVersion(currentVersion, bump) {
 	if (bump === "none") return currentVersion;
 	validateSemver(currentVersion);
 	const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
@@ -433,7 +533,7 @@ function calculateNewVersion(currentVersion, bump) {
 * Create a version update object
 */
 function createVersionUpdate(pkg, bump, hasDirectChanges) {
-	const newVersion = calculateNewVersion(pkg.version, bump);
+	const newVersion = getNextVersion(pkg.version, bump);
 	return {
 		package: pkg,
 		currentVersion: pkg.version,
@@ -443,8 +543,37 @@ function createVersionUpdate(pkg, bump, hasDirectChanges) {
 	};
 }
 /**
-* Update a package.json file with new version and dependency versions
+* Infer version updates from package commits with optional interactive overrides
+*
+* @param workspacePackages - All workspace packages
+* @param packageCommits - Map of package names to their commits
+* @param workspaceRoot - Root directory for prompts
+* @param showPrompt - Whether to show prompts for version overrides
+* @returns Version updates for packages with changes
 */
+async function inferVersionUpdates(workspacePackages, packageCommits, workspaceRoot, showPrompt) {
+	const versionUpdates = [];
+	for (const [pkgName, commits] of packageCommits) {
+		if (commits.length === 0) continue;
+		const pkg = workspacePackages.find((p) => p.name === pkgName);
+		if (!pkg) continue;
+		const bump = determineHighestBump(commits);
+		if (bump === "none") {
+			logger.info(`No version bump needed for package ${pkg.name}`);
+			continue;
+		}
+		let newVersion = getNextVersion(pkg.version, bump);
+		if (!isCI && showPrompt) newVersion = await promptVersionOverride(pkg, workspaceRoot, pkg.version, newVersion, bump);
+		versionUpdates.push({
+			package: pkg,
+			currentVersion: pkg.version,
+			newVersion,
+			bumpType: bump,
+			hasDirectChanges: true
+		});
+	}
+	return versionUpdates;
+}
 async function updatePackageJson(pkg, newVersion, dependencyUpdates) {
 	const packageJsonPath = join(pkg.path, "package.json");
 	const content = await readFile(packageJsonPath, "utf-8");
@@ -569,148 +698,6 @@ async function updateAllPackageJsonFiles(updates) {
 	}));
 }
 
-//#endregion
-//#region src/prompts.ts
-/**
-* Get commits for a package grouped by conventional commit type
-*
-* @param pkg - The workspace package
-* @param workspaceRoot - Root directory of the workspace
-* @param limit - Maximum number of commits to return (default: 10)
-* @returns Commits grouped by type
-*/
-async function getCommitsForPackage(pkg, workspaceRoot, limit = 10) {
-	const limitedCommits = (await getPackageCommits(pkg, workspaceRoot)).slice(0, limit);
-	const grouped = {
-		feat: [],
-		fix: [],
-		perf: [],
-		chore: [],
-		docs: [],
-		style: [],
-		refactor: [],
-		test: [],
-		build: [],
-		ci: [],
-		revert: [],
-		other: []
-	};
-	for (const commit of limitedCommits) if (commit.type && commit.type in grouped) grouped[commit.type].push(commit);
-	else grouped.other.push(commit);
-	return grouped;
-}
-/**
-* Format grouped commits into a readable string
-*/
-function formatCommitGroups(grouped) {
-	const lines = [];
-	const typeLabels = {
-		feat: "Features",
-		fix: "Bug Fixes",
-		perf: "Performance",
-		chore: "Chores",
-		docs: "Documentation",
-		style: "Styling",
-		refactor: "Refactoring",
-		test: "Tests",
-		build: "Build",
-		ci: "CI",
-		revert: "Reverts",
-		other: "Other"
-	};
-	for (const type of [
-		"feat",
-		"fix",
-		"perf",
-		"refactor",
-		"test",
-		"docs",
-		"style",
-		"build",
-		"ci",
-		"chore",
-		"revert",
-		"other"
-	]) {
-		const commits = grouped[type];
-		if (commits.length > 0) {
-			lines.push(`\n${typeLabels[type]}:`);
-			for (const commit of commits) {
-				const scope = commit.scope ? `(${commit.scope})` : "";
-				const breaking = commit.isBreaking ? " ⚠️  BREAKING" : "";
-				lines.push(`  • ${commit.type}${scope}: ${commit.message}${breaking}`);
-			}
-		}
-	}
-	return lines.join("\n");
-}
-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 promptVersionOverride(pkg, workspaceRoot, currentVersion, suggestedVersion, suggestedBumpType) {
-	const commitSummary = formatCommitGroups(await getCommitsForPackage(pkg, workspaceRoot));
-	if (commitSummary.trim()) console.log(`\nRecent changes in ${pkg.name}:${commitSummary}\n`);
-	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"
-	});
-	const response = await prompts([{
-		type: "select",
-		name: "choice",
-		message: `${pkg.name} (${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, workspaceRoot) {
-	const overrides = /* @__PURE__ */ new Map();
-	for (const item of packages) {
-		const newVersion = await promptVersionOverride(item.package, workspaceRoot, item.currentVersion, item.suggestedVersion, item.bumpType);
-		overrides.set(item.package.name, newVersion);
-	}
-	return overrides;
-}
-
 //#endregion
 //#region src/workspace.ts
 async function discoverWorkspacePackages(workspaceRoot, options) {
@@ -720,29 +707,25 @@ async function discoverWorkspacePackages(workspaceRoot, options) {
 	else if (Array.isArray(options.packages)) {
 		workspaceOptions = {
 			excludePrivate: false,
-			included: options.packages
+			include: options.packages
 		};
 		explicitPackages = options.packages;
 	} else {
 		workspaceOptions = options.packages;
-		if (options.packages.included) explicitPackages = options.packages.included;
+		if (options.packages.include) explicitPackages = options.packages.include;
 	}
-	const workspacePackages = await findWorkspacePackages(workspaceRoot, workspaceOptions);
+	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) throw new Error(`Packages not found in workspace: ${missing.join(", ")}`);
+		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");
 	}
-	let packagesToAnalyze = workspacePackages;
 	const isPackagePromptEnabled = options.prompts?.packages !== false;
 	if (!isCI && isPackagePromptEnabled && !explicitPackages) {
 		const selectedNames = await selectPackagePrompt(workspacePackages);
-		packagesToAnalyze = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
+		workspacePackages = workspacePackages.filter((pkg) => selectedNames.includes(pkg.name));
 	}
-	return {
-		workspacePackages,
-		packagesToAnalyze
-	};
+	return workspacePackages;
 }
 async function findWorkspacePackages(workspaceRoot, options) {
 	try {
@@ -769,131 +752,105 @@ async function findWorkspacePackages(workspaceRoot, options) {
 				version: rawProject.version,
 				path: rawProject.path,
 				packageJson,
-				workspaceDependencies: extractWorkspaceDependencies(rawProject.dependencies, allPackageNames),
-				workspaceDevDependencies: extractWorkspaceDependencies(rawProject.devDependencies, allPackageNames)
+				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) console.info(`${farver.cyan("[info]:")} Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
+		if (excludedPackages.size > 0) logger.info(`Excluded packages: ${farver.green(Array.from(excludedPackages).join(", "))}`);
 		return packages.filter((pkg) => pkg !== null);
 	} catch (err) {
-		console.error("Error discovering workspace packages:", err);
+		logger.error("Error discovering workspace packages:", err);
 		throw err;
 	}
 }
 function shouldIncludePackage(pkg, options) {
 	if (!options) return true;
 	if (options.excludePrivate && pkg.private) return false;
-	if (options.included && options.included.length > 0) {
-		if (!options.included.includes(pkg.name)) return false;
+	if (options.include && options.include.length > 0) {
+		if (!options.include.includes(pkg.name)) return false;
 	}
-	if (options.excluded?.includes(pkg.name)) return false;
+	if (options.exclude?.includes(pkg.name)) return false;
 	return true;
 }
-function extractWorkspaceDependencies(dependencies, workspacePackages) {
-	if (!dependencies) return [];
-	return Object.keys(dependencies).filter((dep) => {
-		return workspacePackages.has(dep);
-	});
-}
 
 //#endregion
 //#region src/release.ts
 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 && !await isWorkingDirectoryClean(workspaceRoot)) {
-		console.error("Working directory is not clean. Please commit or stash your changes before proceeding.");
-		return null;
-	}
-	const { workspacePackages, packagesToAnalyze } = await discoverWorkspacePackages(workspaceRoot, options);
-	if (packagesToAnalyze.length === 0) {
-		console.log("No packages found to analyze for release.");
+	const normalizedOptions = normalizeSharedOptions(options);
+	normalizedOptions.dryRun ??= false;
+	normalizedOptions.releaseBranch ??= "release/next";
+	normalizedOptions.safeguards ??= true;
+	globalOptions.dryRun = normalizedOptions.dryRun;
+	const workspaceRoot = normalizedOptions.workspaceRoot;
+	if (normalizedOptions.safeguards && !await isWorkingDirectoryClean(workspaceRoot)) exitWithError("Working directory is not clean. Please commit or stash your changes before proceeding.");
+	const workspacePackages = await discoverWorkspacePackages(workspaceRoot, options);
+	if (workspacePackages.length === 0) {
+		logger.log("No packages found to analyze for release.");
 		return null;
 	}
-	const changedPackages = await analyzeCommits(packagesToAnalyze, workspaceRoot);
-	if (changedPackages.size === 0) throw new Error("No packages have changes requiring a release");
-	let versionUpdates = [];
-	for (const [pkgName, bump] of changedPackages) {
-		const pkg = workspacePackages.find((p) => p.name === pkgName);
-		if (pkg) versionUpdates.push(createVersionUpdate(pkg, bump, true));
-	}
-	const isVersionPromptEnabled = options.prompts?.versions !== false;
-	if (!isCI && isVersionPromptEnabled) {
-		const versionOverrides = await promptVersionOverrides(versionUpdates.map((u) => ({
-			package: u.package,
-			currentVersion: u.currentVersion,
-			suggestedVersion: u.newVersion,
-			bumpType: u.bumpType
-		})), workspaceRoot);
-		versionUpdates = versionUpdates.map((update) => {
-			const overriddenVersion = versionOverrides.get(update.package.name);
-			if (overriddenVersion && overriddenVersion !== update.newVersion) return {
-				...update,
-				newVersion: overriddenVersion
-			};
-			return update;
-		});
-	}
+	const versionUpdates = await inferVersionUpdates(workspacePackages, await getWorkspacePackageCommits(workspaceRoot, workspacePackages), workspaceRoot, options.prompts?.versions !== false);
+	if (versionUpdates.length === 0) exitWithError("No packages have changes requiring a release", "Make sure you have commits since the last release");
 	const allUpdates = createDependentUpdates(buildPackageDependencyGraph(workspacePackages), workspacePackages, versionUpdates);
 	const currentBranch = await getCurrentBranch(workspaceRoot);
 	const existingPullRequest = await getExistingPullRequest({
-		owner,
-		repo,
-		branch: releaseBranch,
-		githubToken
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
+		branch: normalizedOptions.releaseBranch,
+		githubToken: normalizedOptions.githubToken
 	});
 	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 (prExists) logger.log("Existing pull request found:", existingPullRequest.html_url);
+	else logger.log("No existing pull request found, will create new one");
+	const branchExists = await doesBranchExist(normalizedOptions.releaseBranch, workspaceRoot);
 	if (!branchExists) {
-		console.log("Creating release branch:", releaseBranch);
-		await createBranch(releaseBranch, currentBranch, workspaceRoot);
+		logger.log("Creating release branch:", normalizedOptions.releaseBranch);
+		await createBranch(normalizedOptions.releaseBranch, currentBranch, workspaceRoot);
 	}
-	if (!await checkoutBranch(releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${releaseBranch}`);
+	if (!await checkoutBranch(normalizedOptions.releaseBranch, workspaceRoot)) throw new Error(`Failed to checkout branch: ${normalizedOptions.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");
+		logger.log("Pulling latest changes from remote");
+		if (!await pullLatestChanges(normalizedOptions.releaseBranch, workspaceRoot)) logger.log("Warning: Failed to pull latest changes, continuing anyway");
 	}
-	console.log("Rebasing release branch onto", currentBranch);
+	logger.log("Rebasing release branch onto", currentBranch);
 	await rebaseBranch(currentBranch, workspaceRoot);
 	await updateAllPackageJsonFiles(allUpdates);
 	const hasCommitted = await commitChanges("chore: update release versions", workspaceRoot);
-	const isBranchAhead = await isBranchAheadOfRemote(releaseBranch, workspaceRoot);
+	const isBranchAhead = await isBranchAheadOfRemote(normalizedOptions.releaseBranch, workspaceRoot);
 	if (!hasCommitted && !isBranchAhead) {
-		console.log("No changes to commit and branch is in sync with remote");
+		logger.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");
+			logger.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.");
+			logger.error("No changes to commit, and no existing PR. Nothing to do.");
 			return null;
 		}
 	}
-	console.log("Pushing changes to remote");
-	await pushBranch(releaseBranch, workspaceRoot, { forceWithLease: true });
+	logger.log("Pushing changes to remote");
+	await pushBranch(normalizedOptions.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,
+		owner: normalizedOptions.owner,
+		repo: normalizedOptions.repo,
 		pullNumber: existingPullRequest?.number,
 		title: prTitle,
 		body: prBody,
-		head: releaseBranch,
+		head: normalizedOptions.releaseBranch,
 		base: currentBranch,
-		githubToken
+		githubToken: normalizedOptions.githubToken
 	});
-	console.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
+	logger.log(prExists ? "Updated pull request:" : "Created pull request:", pullRequest?.html_url);
 	await checkoutBranch(currentBranch, workspaceRoot);
 	return {
 		updates: allUpdates,
@@ -903,4 +860,4 @@ async function release(options) {
 }
 
 //#endregion
-export { release };
+export { publish, release };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.4",
+  "version": "0.1.0-beta.6",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",
@@ -21,7 +21,6 @@
   "dependencies": {
     "@luxass/utils": "2.7.2",
     "commit-parser": "0.4.5",
-    "eta": "4.0.1",
     "farver": "1.0.0-beta.1",
     "prompts": "2.4.2",
     "tinyexec": "1.0.2"
@@ -31,6 +30,7 @@
     "@types/node": "22.18.12",
     "@types/prompts": "2.4.9",
     "eslint": "9.39.1",
+    "eta": "4.0.1",
     "tsdown": "0.16.0",
     "typescript": "5.9.3",
     "vitest": "4.0.4"