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

package/dist/eta-BV8TCRDW.mjs

@@ -0,0 +1,481 @@
+import * as fs from "node:fs";
+import * as path$2 from "node:path";
+
+//#region node_modules/.pnpm/eta@4.5.1/node_modules/eta/dist/index.mjs
+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;
+	err.cause = originalError;
+	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$2.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$2.join(views, formattedPath);
+		} else resolvedFilePath = path$2.join(path$2.dirname(baseFilePath), templatePath);
+	} else resolvedFilePath = path$2.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$2.relative(parent, dir);
+	return relative && !relative.startsWith("..") && !path$2.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 = (__eta_t, __eta_d) => this.render(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+let includeAsync = (__eta_t, __eta_d) => this.renderAsync(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, 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 + "||{}){" : ""}
+
+function ${config.outputFunctionName}(s){__eta.res+=s;}
+
+${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),
+	outputFunctionName: "output",
+	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

@@ -24,16 +24,20 @@ interface ReleaseScriptsOptionsInput {
   };
   types?: Record<string, {
     title: string;
+    color?: string;
   }>;
   changelog?: {
     enabled?: boolean;
     template?: string;
     emojis?: boolean;
   };
+  npm?: {
+    otp?: string;
+    provenance?: boolean;
+  };
 }
 //#endregion
 //#region src/services/workspace.service.d.ts
-
 declare const WorkspacePackageSchema: Schema.Struct<{
   name: typeof Schema.String;
   version: typeof Schema.String;

package/dist/index.mjs

@@ -1,12 +1,139 @@
+import { t as Eta } from "./eta-BV8TCRDW.mjs";
 import { Console, Context, Data, Effect, Layer, Schema } from "effect";
+import path from "node:path";
 import { Command, CommandExecutor } from "@effect/platform";
 import { NodeCommandExecutor, NodeFileSystem } from "@effect/platform-node";
 import * as CommitParser from "commit-parser";
 import process from "node:process";
 import semver from "semver";
 import fs from "node:fs/promises";
-import path from "node:path";
 
+//#region src/utils/changelog-formatters.ts
+const eta$1 = new Eta();
+/**
+* Pure function to parse commits into changelog entries
+*/
+function parseCommits(commits) {
+	return commits.filter((commit) => commit.isConventional).map((commit) => ({
+		type: commit.type || "other",
+		scope: commit.scope,
+		description: commit.description,
+		breaking: commit.isBreaking || false,
+		hash: commit.hash,
+		shortHash: commit.shortHash,
+		references: commit.references.map((ref) => ({
+			type: ref.type,
+			value: ref.value
+		}))
+	}));
+}
+/**
+* Pure function to group changelog entries by type
+*/
+function groupByType(entries) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const type = entry.breaking ? "breaking" : entry.type;
+		if (!groups.has(type)) groups.set(type, []);
+		groups.get(type).push(entry);
+	}
+	return groups;
+}
+/**
+* Changelog template for Eta rendering
+*/
+const CHANGELOG_TEMPLATE = `# <%= it.packageName %> v<%= it.version %>
+
+**Previous version**: \`<%= it.previousVersion %>\`
+**New version**: \`<%= it.version %>\`
+
+<% if (it.entries.length === 0) { %>
+*No conventional commits found.*
+<% } else { %>
+<% const groups = it.groupedEntries; %>
+<% const typeOrder = ["breaking", "feat", "fix", "perf", "docs", "style", "refactor", "test", "build", "ci", "chore"]; %>
+<% const typeLabels = {
+  breaking: "💥 Breaking Changes",
+  feat: "✨ Features",
+  fix: "🐛 Bug Fixes",
+  perf: "⚡ Performance",
+  docs: "📝 Documentation",
+  style: "💄 Styling",
+  refactor: "♻️ Refactoring",
+  test: "✅ Tests",
+  build: "📦 Build",
+  ci: "👷 CI",
+  chore: "🔧 Chores"
+}; %>
+
+<% for (const type of typeOrder) { %>
+<% const entries = groups.get(type); %>
+<% if (entries && entries.length > 0) { %>
+## <%= typeLabels[type] || type.charAt(0).toUpperCase() + type.slice(1) %>
+
+<% for (const entry of entries) { %>
+- <% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %><% if (entry.references.length > 0) { %> (<%= entry.references.map(r => "#" + r.value).join(", ") %>)<% } %> (\`<%= entry.shortHash %>\`)
+<% } %>
+
+<% } %>
+<% } %>
+
+<% for (const [type, entries] of groups) { %>
+<% if (!typeOrder.includes(type)) { %>
+## <%= type.charAt(0).toUpperCase() + type.slice(1) %>
+
+<% for (const entry of entries) { %>
+- <% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %> (\`<%= entry.shortHash %>\`)
+<% } %>
+
+<% } %>
+<% } %>
+<% } %>`;
+/**
+* Pure function to format changelog as markdown
+*/
+function formatChangelogMarkdown(changelog) {
+	const groups = groupByType(changelog.entries);
+	return eta$1.renderString(CHANGELOG_TEMPLATE, {
+		packageName: changelog.packageName,
+		version: changelog.version,
+		previousVersion: changelog.previousVersion,
+		entries: changelog.entries,
+		groupedEntries: groups
+	});
+}
+/**
+* Pure function to create a changelog object
+*/
+function createChangelog(packageName, version, previousVersion, commits) {
+	return {
+		packageName,
+		version,
+		previousVersion,
+		entries: parseCommits(commits)
+	};
+}
+
+//#endregion
+//#region src/services/changelog.service.ts
+var ChangelogService = class extends Effect.Service()("@ucdjs/release-scripts/ChangelogService", {
+	effect: Effect.gen(function* () {
+		function generateChangelog(pkg, newVersion, commits) {
+			return Effect.gen(function* () {
+				const changelog = createChangelog(pkg.name, newVersion, pkg.version, commits);
+				return {
+					changelog,
+					markdown: formatChangelogMarkdown(changelog),
+					filePath: `${pkg.path}/CHANGELOG.md`
+				};
+			});
+		}
+		return { generateChangelog };
+	}),
+	dependencies: []
+}) {};
+
+//#endregion
 //#region src/services/dependency-graph.service.ts
 var DependencyGraphService = class extends Effect.Service()("@ucdjs/release-scripts/DependencyGraphService", {
 	effect: Effect.gen(function* () {
@@ -81,21 +208,42 @@ var WorkspaceError = class extends Data.TaggedError("WorkspaceError") {};
 var GitHubError = class extends Data.TaggedError("GitHubError") {};
 var VersionCalculationError = class extends Data.TaggedError("VersionCalculationError") {};
 var OverridesLoadError = class extends Data.TaggedError("OverridesLoadError") {};
+var NPMError = class extends Data.TaggedError("NPMError") {};
+var PublishError = class extends Data.TaggedError("PublishError") {};
+var TagError = class extends Data.TaggedError("TagError") {};
 
 //#endregion
 //#region src/options.ts
 const DEFAULT_PR_BODY_TEMPLATE = `## Summary\n\nThis PR contains the following changes:\n\n- Updated package versions\n- Updated changelogs\n\n## Packages\n\nThe following packages will be released:\n\n{{packages}}`;
 const DEFAULT_CHANGELOG_TEMPLATE = `# Changelog\n\n{{releases}}`;
 const DEFAULT_TYPES = {
-	feat: { title: "🚀 Features" },
-	fix: { title: "🐞 Bug Fixes" },
-	refactor: { title: "🔧 Code Refactoring" },
-	perf: { title: "🏎 Performance" },
-	docs: { title: "📚 Documentation" },
-	style: { title: "🎨 Styles" }
+	feat: {
+		title: "🚀 Features",
+		color: "green"
+	},
+	fix: {
+		title: "🐞 Bug Fixes",
+		color: "red"
+	},
+	refactor: {
+		title: "🔧 Code Refactoring",
+		color: "blue"
+	},
+	perf: {
+		title: "🏎 Performance",
+		color: "orange"
+	},
+	docs: {
+		title: "📚 Documentation",
+		color: "purple"
+	},
+	style: {
+		title: "🎨 Styles",
+		color: "pink"
+	}
 };
 function normalizeReleaseScriptsOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false } = options;
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false, npm = {} } = options;
 	const token = githubToken.trim();
 	if (!token) throw new Error("GitHub token is required. Pass it in via options.");
 	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) throw new Error("Repository (repo) is required. Specify in 'owner/repo' format (e.g., 'octocat/hello-world').");
@@ -129,7 +277,11 @@ function normalizeReleaseScriptsOptions(options) {
 		types: options.types ? {
 			...DEFAULT_TYPES,
 			...types
-		} : DEFAULT_TYPES
+		} : DEFAULT_TYPES,
+		npm: {
+			otp: npm.otp,
+			provenance: npm.provenance ?? true
+		}
 	};
 }
 var ReleaseScriptsOptions = class extends Context.Tag("@ucdjs/release-scripts/ReleaseScriptsOptions")() {};
@@ -176,6 +328,9 @@ var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitServi
 		function checkoutBranch(branch) {
 			return execGitCommand(["checkout", branch]);
 		}
+		function rebaseBranch(onto) {
+			return execGitCommandIfNotDry(["rebase", onto]);
+		}
 		function stageChanges(files) {
 			return Effect.gen(function* () {
 				if (files.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("No files to stage."));
@@ -196,6 +351,14 @@ var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitServi
 				branch
 			]);
 		}
+		function forcePushChanges(branch, remote = "origin") {
+			return execGitCommandIfNotDry([
+				"push",
+				"--force-with-lease",
+				remote,
+				branch
+			]);
+		}
 		function readFile(filePath, ref = "HEAD") {
 			return execGitCommand(["show", `${ref}:${filePath}`]);
 		}
@@ -215,6 +378,32 @@ var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitServi
 				})));
 			}));
 		}
+		function createTag(name, message) {
+			return execGitCommandIfNotDry(message ? [
+				"tag",
+				"-a",
+				name,
+				"-m",
+				message
+			] : ["tag", name]).pipe(Effect.mapError((err) => new TagError({
+				message: `Failed to create tag "${name}"`,
+				tagName: name,
+				operation: "create",
+				cause: err
+			})));
+		}
+		function pushTag(name, remote = "origin") {
+			return execGitCommandIfNotDry([
+				"push",
+				remote,
+				name
+			]).pipe(Effect.mapError((err) => new TagError({
+				message: `Failed to push tag "${name}" to ${remote}`,
+				tagName: name,
+				operation: "push",
+				cause: err
+			})));
+		}
 		function getCommits(options) {
 			return Effect.tryPromise({
 				try: async () => CommitParser.getCommits({
@@ -264,16 +453,22 @@ var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitServi
 				exists: doesBranchExist,
 				create: createBranch,
 				checkout: checkoutBranch,
+				rebase: rebaseBranch,
 				get: getBranch
 			},
 			commits: {
 				stage: stageChanges,
 				write: writeCommit,
 				push: pushChanges,
+				forcePush: forcePushChanges,
 				get: getCommits,
 				filesChangesBetweenRefs
 			},
-			tags: { mostRecentForPackage: getMostRecentPackageTag },
+			tags: {
+				mostRecentForPackage: getMostRecentPackageTag,
+				create: createTag,
+				push: pushTag
+			},
 			workspace: {
 				readFile,
 				isWithinRepository,
@@ -287,6 +482,7 @@ var GitService = class extends Effect.Service()("@ucdjs/release-scripts/GitServi
 
 //#endregion
 //#region src/services/github.service.ts
+const eta = new Eta();
 const PullRequestSchema = Schema.Struct({
 	number: Schema.Number,
 	title: Schema.String,
@@ -370,7 +566,128 @@ var GitHubService = class extends Effect.Service()("@ucdjs/release-scripts/GitHu
 				cause: e.cause
 			})));
 		}
-		return { getPullRequestByBranch };
+		function setCommitStatus(sha, status) {
+			return makeRequest(`statuses/${sha}`, Schema.Unknown, {
+				method: "POST",
+				body: JSON.stringify(status)
+			}).pipe(Effect.map(() => status), Effect.catchAll((e) => Effect.fail(new GitHubError({
+				message: e.message,
+				operation: "setCommitStatus",
+				cause: e.cause
+			}))));
+		}
+		function updatePullRequest(number, options) {
+			return makeRequest(`pulls/${number}`, PullRequestSchema, {
+				method: "PATCH",
+				body: JSON.stringify(options)
+			}).pipe(Effect.mapError((e) => new GitHubError({
+				message: e.message,
+				operation: "updatePullRequest",
+				cause: e.cause
+			})));
+		}
+		const prBodyTemplate = `## Release Summary
+
+This PR prepares the release of <%= it.count %> package<%= it.count === 1 ? "" : "s" %>:
+
+<% for (const release of it.releases) { %>
+- **<%= release.packageName %>**: \`<%= release.previousVersion %>\` → \`<%= release.version %>\`
+<% } %>
+
+## Changes
+
+See individual package changelogs for details.
+`;
+		function generateReleasePRBody(releases) {
+			return Effect.gen(function* () {
+				return eta.renderString(prBodyTemplate, {
+					count: releases.length,
+					releases
+				});
+			});
+		}
+		return {
+			getPullRequestByBranch,
+			setCommitStatus,
+			updatePullRequest,
+			generateReleasePRBody
+		};
+	}),
+	dependencies: []
+}) {};
+
+//#endregion
+//#region src/services/npm.service.ts
+const PackumentSchema = Schema.Struct({
+	"name": Schema.String,
+	"dist-tags": Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}),
+	"versions": Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({
+			name: Schema.String,
+			version: Schema.String,
+			description: Schema.optional(Schema.String),
+			dist: Schema.Struct({
+				tarball: Schema.String,
+				shasum: Schema.String,
+				integrity: Schema.optional(Schema.String)
+			})
+		})
+	})
+});
+var NPMService = class extends Effect.Service()("@ucdjs/release-scripts/NPMService", {
+	effect: Effect.gen(function* () {
+		const executor = yield* CommandExecutor.CommandExecutor;
+		const config = yield* ReleaseScriptsOptions;
+		const fetchPackument = (packageName) => Effect.tryPromise({
+			try: async () => {
+				const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+				if (response.status === 404) return null;
+				if (!response.ok) throw new Error(`Failed to fetch packument: ${response.statusText}`);
+				return await response.json();
+			},
+			catch: (error) => {
+				return new NPMError({
+					message: error instanceof Error ? error.message : String(error),
+					operation: "fetchPackument"
+				});
+			}
+		}).pipe(Effect.flatMap((data) => {
+			if (data === null) return Effect.succeed(null);
+			return Schema.decodeUnknown(PackumentSchema)(data).pipe(Effect.mapError((error) => new NPMError({
+				message: `Failed to parse packument: ${error}`,
+				operation: "fetchPackument"
+			})));
+		}));
+		const versionExists = (packageName, version) => fetchPackument(packageName).pipe(Effect.map((packument) => {
+			if (!packument) return false;
+			return version in packument.versions;
+		}));
+		const getLatestVersion = (packageName) => fetchPackument(packageName).pipe(Effect.map((packument) => {
+			if (!packument) return null;
+			return packument["dist-tags"].latest || null;
+		}));
+		const publish = (options) => Effect.gen(function* () {
+			const args = ["publish"];
+			if (options.tagName) args.push("--tag", options.tagName);
+			if (options.otp) args.push("--otp", options.otp);
+			if (options.provenance !== false) args.push("--provenance");
+			if (options.dryRun ?? config.dryRun) args.push("--dry-run");
+			const command = Command.make("pnpm", ...args).pipe(Command.workingDirectory(options.packagePath));
+			return (yield* executor.string(command).pipe(Effect.mapError((err) => new PublishError({
+				message: `Failed to publish package at ${options.packagePath}: ${err.message}`,
+				cause: err
+			})))).trim();
+		});
+		return {
+			fetchPackument,
+			versionExists,
+			getLatestVersion,
+			publish
+		};
 	}),
 	dependencies: []
 }) {};
@@ -839,8 +1156,257 @@ function findCommitRange(packages) {
 	return [oldestCommit.hash, newestCommit.hash];
 }
 
+//#endregion
+//#region src/prepare.ts
+function constructPrepareProgram(config) {
+	return Effect.gen(function* () {
+		const changelog = yield* ChangelogService;
+		const git = yield* GitService;
+		const github = yield* GitHubService;
+		const dependencyGraph = yield* DependencyGraphService;
+		const packageUpdater = yield* PackageUpdaterService;
+		const versionCalculator = yield* VersionCalculatorService;
+		const workspace = yield* WorkspaceService;
+		yield* git.workspace.assertWorkspaceReady;
+		const releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
+		if (!releasePullRequest || !releasePullRequest.head) return yield* Effect.fail(/* @__PURE__ */ new Error(`Release pull request for branch "${config.branch.release}" does not exist.`));
+		yield* Console.log(`✅ Release pull request #${releasePullRequest.number} exists.`);
+		if ((yield* git.branches.get) !== config.branch.release) {
+			yield* git.branches.checkout(config.branch.release);
+			yield* Console.log(`✅ Checked out to release branch "${config.branch.release}".`);
+		}
+		yield* Console.log(`🔄 Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
+		yield* git.branches.rebase(config.branch.default);
+		yield* Console.log(`✅ Rebase complete.`);
+		const overrides = yield* loadOverrides({
+			sha: config.branch.default,
+			overridesPath: ".github/ucdjs-release.overrides.json"
+		});
+		if (Object.keys(overrides).length > 0) yield* Console.log("📋 Loaded version overrides:", overrides);
+		const originalBranch = yield* git.branches.get;
+		yield* git.branches.checkout(config.branch.default);
+		const packages = yield* workspace.discoverWorkspacePackages.pipe(Effect.flatMap(mergePackageCommitsIntoPackages), Effect.flatMap((pkgs) => mergeCommitsAffectingGloballyIntoPackage(pkgs, config.globalCommitMode)));
+		yield* Console.log(`📦 Discovered ${packages.length} packages with commits.`);
+		const releases = yield* versionCalculator.calculateBumps(packages, overrides);
+		yield* dependencyGraph.topologicalOrder(packages);
+		const releasesCount = releases.length;
+		yield* Console.log(`📊 ${releasesCount} package${releasesCount === 1 ? "" : "s"} will be released.`);
+		yield* git.branches.checkout(originalBranch);
+		yield* Console.log("✏️  Updating package.json files...");
+		yield* packageUpdater.applyReleases(packages, releases);
+		yield* Console.log("✅ package.json files updated.");
+		yield* Console.log("📝 Generating changelogs...");
+		const changelogFiles = [];
+		for (const release of releases) {
+			const pkg = packages.find((p) => p.name === release.package.name);
+			if (!pkg || !pkg.commits) continue;
+			const result = yield* changelog.generateChangelog(pkg, release.newVersion, pkg.commits);
+			yield* Effect.tryPromise({
+				try: async () => {
+					await (await import("node:fs/promises")).writeFile(result.filePath, result.markdown, "utf-8");
+				},
+				catch: (e) => /* @__PURE__ */ new Error(`Failed to write changelog: ${String(e)}`)
+			});
+			changelogFiles.push(result.filePath);
+		}
+		yield* Console.log(`✅ Generated ${changelogFiles.length} changelog file${changelogFiles.length === 1 ? "" : "s"}.`);
+		const filesToStage = [...releases.map((r) => `${r.package.path}/package.json`), ...changelogFiles];
+		yield* Console.log(`📌 Staging ${filesToStage.length} file${filesToStage.length === 1 ? "" : "s"}...`);
+		yield* git.commits.stage(filesToStage);
+		const commitMessage = `chore(release): prepare release
+
+${releasesCount} package${releasesCount === 1 ? "" : "s"} updated:
+${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
+		yield* Console.log("💾 Creating commit...");
+		yield* git.commits.write(commitMessage);
+		yield* Console.log("✅ Commit created.");
+		yield* Console.log(`⬆️  Force pushing to "${config.branch.release}"...`);
+		yield* git.commits.forcePush(config.branch.release);
+		yield* Console.log("✅ Force push complete.");
+		yield* Console.log("📄 Updating pull request...");
+		const prBody = yield* github.generateReleasePRBody(releases.map((r) => ({
+			packageName: r.package.name,
+			version: r.newVersion,
+			previousVersion: r.package.version
+		})));
+		yield* github.updatePullRequest(releasePullRequest.number, { body: prBody });
+		yield* Console.log("✅ Pull request updated.");
+		yield* Console.log(`\n🎉 Release preparation complete! View PR: #${releasePullRequest.number}`);
+	});
+}
+
+//#endregion
+//#region src/publish.ts
+function isPrerelease(version) {
+	const parsed = semver.parse(version);
+	return parsed !== null && parsed.prerelease.length > 0;
+}
+function getDistTag(version) {
+	return isPrerelease(version) ? "next" : "latest";
+}
+function buildPackage(packagePath) {
+	return Effect.gen(function* () {
+		const executor = yield* CommandExecutor.CommandExecutor;
+		const command = Command.make("pnpm", "run", "build").pipe(Command.workingDirectory(packagePath));
+		return (yield* executor.string(command).pipe(Effect.mapError((err) => /* @__PURE__ */ new Error(`Failed to build package at ${packagePath}: ${err.message}`)))).trim();
+	});
+}
+function constructPublishProgram(config) {
+	return Effect.gen(function* () {
+		const git = yield* GitService;
+		const npm = yield* NPMService;
+		const workspace = yield* WorkspaceService;
+		const dependencyGraph = yield* DependencyGraphService;
+		yield* git.workspace.assertWorkspaceReady;
+		const currentBranch = yield* git.branches.get;
+		if (currentBranch !== config.branch.default) return yield* Effect.fail(/* @__PURE__ */ new Error(`Publish must be run on the default branch "${config.branch.default}". Current branch: "${currentBranch}"`));
+		yield* Console.log(`✅ On default branch "${config.branch.default}".`);
+		const publicPackages = (yield* workspace.discoverWorkspacePackages).filter((pkg) => !pkg.packageJson.private);
+		yield* Console.log(`📦 Found ${publicPackages.length} public package${publicPackages.length === 1 ? "" : "s"} to check.`);
+		const orderedPackages = yield* dependencyGraph.topologicalOrder(publicPackages);
+		const results = [];
+		for (const updateOrder of orderedPackages) {
+			const pkg = updateOrder.package;
+			const version = pkg.version;
+			const tagName = `${pkg.name}@${version}`;
+			if (yield* npm.versionExists(pkg.name, version)) {
+				yield* Console.log(`⏭️  Skipping ${pkg.name}@${version} - already published.`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "skipped",
+					reason: "Already published to npm"
+				});
+				continue;
+			}
+			yield* Console.log(`🔨 Building ${pkg.name}...`);
+			yield* buildPackage(pkg.path);
+			yield* Console.log(`✅ Build complete for ${pkg.name}.`);
+			const distTag = getDistTag(version);
+			yield* Console.log(`🚀 Publishing ${pkg.name}@${version} with tag "${distTag}"...`);
+			const publishResult = yield* npm.publish({
+				packagePath: pkg.path,
+				tagName: distTag,
+				otp: config.npm.otp,
+				provenance: config.npm.provenance,
+				dryRun: config.dryRun
+			}).pipe(Effect.map(() => ({ success: true })), Effect.catchAll((err) => Effect.succeed({
+				success: false,
+				error: err
+			})));
+			if (publishResult.success) {
+				yield* Console.log(`✅ Published ${pkg.name}@${version}.`);
+				if (!config.dryRun) {
+					yield* Console.log(`🏷️  Creating tag ${tagName}...`);
+					yield* git.tags.create(tagName, `Release ${tagName}`);
+					yield* git.tags.push(tagName);
+					yield* Console.log(`✅ Tag ${tagName} created and pushed.`);
+				} else yield* Console.log(`🏷️  [Dry Run] Would create and push tag ${tagName}.`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "published"
+				});
+			} else {
+				const error = publishResult.error;
+				yield* Console.log(`❌ Failed to publish ${pkg.name}@${version}: ${error.message}`);
+				results.push({
+					packageName: pkg.name,
+					version,
+					status: "failed",
+					reason: error.message
+				});
+			}
+		}
+		const published = results.filter((r) => r.status === "published");
+		const skipped = results.filter((r) => r.status === "skipped");
+		const failed = results.filter((r) => r.status === "failed");
+		yield* Console.log("\n📊 Publish Summary:");
+		yield* Console.log(`   Published: ${published.length}`);
+		yield* Console.log(`   Skipped: ${skipped.length}`);
+		yield* Console.log(`   Failed: ${failed.length}`);
+		if (failed.length > 0) {
+			yield* Console.log("\n❌ Failed packages:");
+			for (const f of failed) yield* Console.log(`   - ${f.packageName}@${f.version}: ${f.reason}`);
+			return yield* Effect.fail(/* @__PURE__ */ new Error("Some packages failed to publish."));
+		}
+		if (published.length === 0 && skipped.length > 0) yield* Console.log("\n✅ All packages were already published.");
+		else if (published.length > 0) yield* Console.log("\n🎉 Publish complete!");
+	});
+}
+
 //#endregion
 //#region src/verify.ts
+function satisfiesRange(range, version) {
+	return semver.satisfies(version, range, { includePrerelease: true });
+}
+function snapshotPackageJson(pkg, ref) {
+	return Effect.gen(function* () {
+		return yield* (yield* GitService).workspace.readFile(`${pkg.path}/package.json`, ref).pipe(Effect.flatMap((content) => Effect.try({
+			try: () => JSON.parse(content),
+			catch: (e) => /* @__PURE__ */ new Error(`Failed to parse package.json for ${pkg.name} at ${ref}: ${String(e)}`)
+		})));
+	});
+}
+function findDrift(packages, releases, branchSnapshots) {
+	const releaseVersionByName = /* @__PURE__ */ new Map();
+	for (const rel of releases) releaseVersionByName.set(rel.package.name, rel.newVersion);
+	const reasons = [];
+	for (const pkg of packages) {
+		const snapshot = branchSnapshots.get(pkg.name);
+		if (snapshot == null) {
+			reasons.push({
+				packageName: pkg.name,
+				reason: "package.json missing on release branch"
+			});
+			continue;
+		}
+		if (snapshot instanceof Error) {
+			reasons.push({
+				packageName: pkg.name,
+				reason: snapshot.message
+			});
+			continue;
+		}
+		const expectedVersion = releaseVersionByName.get(pkg.name) ?? pkg.version;
+		const branchVersion = typeof snapshot.version === "string" ? snapshot.version : void 0;
+		if (!branchVersion) {
+			reasons.push({
+				packageName: pkg.name,
+				reason: "package.json on release branch lacks version"
+			});
+			continue;
+		}
+		if (branchVersion !== expectedVersion) reasons.push({
+			packageName: pkg.name,
+			reason: `version mismatch: expected ${expectedVersion}, found ${branchVersion}`
+		});
+		for (const section of [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]) {
+			const deps = snapshot[section];
+			if (!deps || typeof deps !== "object") continue;
+			for (const [depName, range] of Object.entries(deps)) {
+				const bumpedVersion = releaseVersionByName.get(depName);
+				if (!bumpedVersion) continue;
+				if (typeof range !== "string") {
+					reasons.push({
+						packageName: pkg.name,
+						reason: `${section}.${depName} is not a string range`
+					});
+					continue;
+				}
+				if (!satisfiesRange(range, bumpedVersion)) reasons.push({
+					packageName: pkg.name,
+					reason: `${section}.${depName} does not include ${bumpedVersion}`
+				});
+			}
+		}
+	}
+	return reasons;
+}
 function constructVerifyProgram(config) {
 	return Effect.gen(function* () {
 		const git = yield* GitService;
@@ -867,6 +1433,26 @@ function constructVerifyProgram(config) {
 		const ordered = yield* dependencyGraph.topologicalOrder(packages);
 		yield* Console.log("Calculated releases:", releases);
 		yield* Console.log("Release order:", ordered);
+		const releaseHeadSha = releasePullRequest.head.sha;
+		const branchSnapshots = /* @__PURE__ */ new Map();
+		for (const pkg of packages) {
+			const snapshot = yield* snapshotPackageJson(pkg, releaseHeadSha).pipe(Effect.catchAll((err) => Effect.succeed(err instanceof Error ? err : new Error(String(err)))));
+			branchSnapshots.set(pkg.name, snapshot);
+		}
+		const drift = findDrift(packages, releases, branchSnapshots);
+		if (drift.length === 0) yield* Console.log("✅ Release branch is in sync with expected releases.");
+		else yield* Console.log("❌ Release branch is out of sync:", drift);
+		const status = drift.length === 0 ? {
+			state: "success",
+			description: "Release artifacts in sync",
+			context: "release/verify"
+		} : {
+			state: "failure",
+			description: "Release branch out of sync",
+			context: "release/verify"
+		};
+		yield* github.setCommitStatus(releaseHeadSha, status);
+		if (drift.length > 0) return yield* Effect.fail(/* @__PURE__ */ new Error("Release branch is out of sync."));
 	});
 }
 
@@ -874,7 +1460,7 @@ function constructVerifyProgram(config) {
 //#region src/index.ts
 async function createReleaseScripts(options) {
 	const config = normalizeReleaseScriptsOptions(options);
-	const AppLayer = Layer.succeed(ReleaseScriptsOptions, config).pipe(Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer), Layer.provide(GitService.Default), Layer.provide(GitHubService.Default), Layer.provide(DependencyGraphService.Default), Layer.provide(PackageUpdaterService.Default), Layer.provide(VersionCalculatorService.Default), Layer.provide(WorkspaceService.Default));
+	const AppLayer = Layer.succeed(ReleaseScriptsOptions, config).pipe(Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer), Layer.provide(ChangelogService.Default), Layer.provide(GitService.Default), Layer.provide(GitHubService.Default), Layer.provide(DependencyGraphService.Default), Layer.provide(NPMService.Default), Layer.provide(PackageUpdaterService.Default), Layer.provide(VersionCalculatorService.Default), Layer.provide(WorkspaceService.Default));
 	const runProgram = (program) => {
 		const provided = program.pipe(Effect.provide(AppLayer));
 		return Effect.runPromise(provided);
@@ -894,39 +1480,10 @@ async function createReleaseScripts(options) {
 			return runProgram(constructVerifyProgram(config));
 		},
 		async prepare() {
-			return runProgram(Effect.gen(function* () {
-				const git = yield* GitService;
-				const github = yield* GitHubService;
-				const dependencyGraph = yield* DependencyGraphService;
-				const packageUpdater = yield* PackageUpdaterService;
-				const versionCalculator = yield* VersionCalculatorService;
-				const workspace = yield* WorkspaceService;
-				yield* safeguardProgram;
-				const releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
-				if (!releasePullRequest || !releasePullRequest.head) return yield* Effect.fail(/* @__PURE__ */ new Error(`Release pull request for branch "${config.branch.release}" does not exist.`));
-				yield* Console.log(`✅ Release pull request #${releasePullRequest.number} exists.`);
-				if ((yield* git.branches.get) !== config.branch.default) {
-					yield* git.branches.checkout(config.branch.default);
-					yield* Console.log(`✅ Checked out to default branch "${config.branch.default}".`);
-				}
-				const overrides = yield* loadOverrides({
-					sha: releasePullRequest.head.sha,
-					overridesPath: ".github/ucdjs-release.overrides.json"
-				});
-				yield* Console.log("Loaded overrides:", overrides);
-				const packages = yield* workspace.discoverWorkspacePackages.pipe(Effect.flatMap(mergePackageCommitsIntoPackages), Effect.flatMap((pkgs) => mergeCommitsAffectingGloballyIntoPackage(pkgs, config.globalCommitMode)));
-				yield* Console.log("Discovered packages with commits and global commits:", packages);
-				const releases = yield* versionCalculator.calculateBumps(packages, overrides);
-				const ordered = yield* dependencyGraph.topologicalOrder(packages);
-				yield* Console.log("Calculated releases:", releases);
-				yield* Console.log("Release order:", ordered);
-				yield* packageUpdater.applyReleases(packages, releases);
-			}));
+			return runProgram(constructPrepareProgram(config));
 		},
 		async publish() {
-			return runProgram(Effect.gen(function* () {
-				return yield* Effect.fail(/* @__PURE__ */ new Error("Not implemented yet."));
-			}));
+			return runProgram(constructPublishProgram(config));
 		},
 		packages: {
 			async list() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.25",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",
@@ -15,37 +15,35 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@effect/platform": "0.93.6",
-    "@effect/platform-node": "0.103.0",
-    "@luxass/utils": "2.7.2",
+    "@effect/platform": "0.94.4",
+    "@effect/platform-node": "0.104.1",
+    "@luxass/utils": "2.7.3",
     "commit-parser": "1.3.0",
-    "effect": "3.19.9",
+    "effect": "3.19.16",
     "farver": "1.0.0-beta.1",
     "mri": "1.2.0",
     "prompts": "2.4.2",
-    "semver": "7.7.3",
+    "semver": "7.7.4",
     "tinyexec": "1.0.2"
   },
   "devDependencies": {
-    "@effect/language-service": "^0.60.0",
+    "@effect/language-service": "^0.73.1",
     "@effect/vitest": "0.27.0",
-    "@luxass/eslint-config": "6.0.3",
+    "@luxass/eslint-config": "7.2.0",
     "@types/node": "22.18.12",
     "@types/prompts": "2.4.9",
     "@types/semver": "7.7.1",
-    "eslint": "9.39.1",
-    "eta": "4.4.1",
-    "tsdown": "0.17.0",
+    "eslint": "10.0.0",
+    "eta": "4.5.1",
+    "tsdown": "0.20.3",
     "typescript": "5.9.3",
-    "vitest": "4.0.15",
-    "vitest-testdirs": "4.3.0"
+    "vitest": "4.0.18",
+    "vitest-testdirs": "4.4.2"
   },
   "scripts": {
     "build": "tsdown",