rylease 0.0.0-stage → 3.0.0

package/dist/index.mjs

@@ -0,0 +1,4928 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { createRequire } from "node:module";
+import { access, glob, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import * as z from "zod";
+import { pathToFileURL } from "node:url";
+import { performance } from "node:perf_hooks";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promisify } from "node:util";
+import { crc32, deflateRaw } from "node:zlib";
+import { homedir, tmpdir } from "node:os";
+//#region src/core/options.ts
+/** Options that don't match a step's schema; the message lists every problem. */
+var OptionsError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.join("\n"));
+		this.name = "OptionsError";
+		this.issues = issues;
+	}
+};
+/**
+* Validates options against a shape, applying defaults. Unknown keys are
+* rejected. Each problem is reported with `path` prepended, e.g.
+* `conventional/determine-kind.types.docs: Invalid option: ...`.
+*/
+function parseOptions(shape, value, path) {
+	const result = z.strictObject(shape).safeParse(value ?? {});
+	if (result.success) return result.data;
+	throw new OptionsError(result.error.issues.map((issue) => `${joinPath(path, issue.path)}: ${issue.message}`));
+}
+function joinPath(path, keys = []) {
+	return keys.reduce((text, key) => typeof key === "number" ? `${text}[${key}]` : /^[\w-]+$/.test(String(key)) ? `${text}.${String(key)}` : `${text}[${JSON.stringify(String(key))}]`, path);
+}
+//#endregion
+//#region src/core/factory.ts
+/** Makes a factory that validates its options on every call. */
+function makeFactory(kind, definition) {
+	const shape = definition.options ?? {};
+	const factory = (options) => definition.create(parseOptions(shape, options, definition.name));
+	return Object.defineProperties(factory, {
+		kind: {
+			value: kind,
+			enumerable: true
+		},
+		name: {
+			value: definition.name,
+			enumerable: true
+		},
+		description: {
+			value: definition.description,
+			enumerable: true
+		},
+		options: {
+			value: shape,
+			enumerable: true
+		}
+	});
+}
+/** Whether a value is a factory, of any kind or of the given one. */
+function isFactory(value, kind) {
+	if (typeof value !== "function") return false;
+	const factory = value;
+	return typeof factory.kind === "string" && (kind === void 0 || factory.kind === kind) && typeof factory.name === "string";
+}
+//#endregion
+//#region src/core/components.ts
+/** Defines a source of components, with options as a zod shape. */
+function defineComponents(definition) {
+	return makeFactory("components", definition);
+}
+/**
+* Checks components and fills in their defaults, ordered so that each comes
+* after the components it depends on.
+*/
+function resolveComponents(components, defaults) {
+	const issues = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [index, component] of components.entries()) {
+		if (typeof component.name !== "string" || component.name === "") issues.push(`components[${index}].name: expected a name`);
+		else if (names.has(component.name)) issues.push(`components[${index}].name: '${component.name}' is listed twice`);
+		names.add(component.name);
+	}
+	const paths = components.map((component, index) => {
+		const path = normalize(component.path ?? ".").replaceAll(sep, "/");
+		if (isAbsolute(path) || path === ".." || path.startsWith("../")) issues.push(`components[${index}].path: '${component.path}' must be inside the project`);
+		return path.replace(/\/$/, "");
+	});
+	for (const [index, component] of components.entries()) for (const dependency of component.dependsOn ?? []) if (!names.has(dependency)) issues.push(`components[${index}].dependsOn: '${dependency}' isn't a component`);
+	const several = components.length > 1;
+	const tags = components.map((component) => {
+		return (component.tag ?? defaults.tag ?? (several ? "{name}@{version}" : "v{version}")).replaceAll("{name}", component.name);
+	});
+	for (const [index, tag] of tags.entries()) {
+		const at = components[index]?.tag === void 0 ? "tag" : `components[${index}].tag`;
+		const unknown = [...tag.matchAll(/\{(\w+)\}/g)].map(([, name]) => name).filter((name) => name !== "version");
+		if (!tag.includes("{version}")) issues.push(`${at}: '${tag}' has no {version} placeholder`);
+		else if (unknown.length > 0) issues.push(`${at}: unknown placeholder {${unknown[0]}} in '${tag}'; use {version} or {name}`);
+	}
+	const seen = /* @__PURE__ */ new Map();
+	for (const [index, tag] of tags.entries()) {
+		const other = seen.get(tag);
+		const name = components[index]?.name ?? "";
+		if (other !== void 0) issues.push(`components: '${other}' and '${name}' share the tag '${tag}'; add {name} to it`);
+		seen.set(tag, name);
+	}
+	if (issues.length > 0) throw new OptionsError(issues);
+	return dependencyOrder(components.map((component, index) => {
+		const path = paths[index] ?? ".";
+		const nested = paths.filter((other, i) => i !== index && isInside(other, path));
+		const whole = path === "." && nested.length === 0;
+		return {
+			info: {
+				name: component.name,
+				path,
+				dependsOn: [...component.dependsOn ?? []],
+				pathspec: whole ? [] : [path, ...nested.map((other) => `:(exclude)${other}`)]
+			},
+			scheme: component.scheme ?? defaults.scheme,
+			history: component.history ?? defaults.history,
+			tag: tags[index] ?? ""
+		};
+	}));
+}
+/** Whether `path` is strictly inside `parent`, both relative to the project. */
+function isInside(path, parent) {
+	if (path === parent) return false;
+	if (parent === ".") return path !== ".";
+	const between = relative(parent, path);
+	return between !== "" && !between.startsWith("..") && !isAbsolute(between);
+}
+/** Dependencies first, otherwise in the order given. */
+function dependencyOrder(components) {
+	const ordered = [];
+	const done = /* @__PURE__ */ new Set();
+	let remaining = components;
+	while (remaining.length > 0) {
+		const ready = remaining.filter(({ info }) => info.dependsOn.every((name) => done.has(name)));
+		if (ready.length === 0) throw new OptionsError([`components: ${remaining.map(({ info }) => info.name).join(", ")} depend on each other in a cycle`]);
+		for (const component of ready) {
+			ordered.push(component);
+			done.add(component.info.name);
+		}
+		remaining = remaining.filter((component) => !ready.includes(component));
+	}
+	return ordered;
+}
+//#endregion
+//#region src/utils/files.ts
+/**
+* A path relative to a component's directory: where it is, and how it's
+* written relative to the project, e.g. in `files` and reasons.
+*/
+function inComponent(env, component, path) {
+	return {
+		file: resolve(env.cwd, component.path, path),
+		relative: posix.normalize(posix.join(component.path, path.replaceAll("\\", "/")))
+	};
+}
+/**
+* Resolves globs, relative to `cwd` unless absolute, to the absolute paths of
+* the files they match, sorted; a directory stands for every file in it.
+* Every pattern must match something, so a typo fails instead of uploading
+* nothing.
+*/
+async function resolveFiles(cwd, patterns) {
+	const files = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		const normalized = pattern.replaceAll("\\", "/");
+		let matched = false;
+		for await (const match of glob(normalized, { cwd })) {
+			const path = isAbsolute(match) ? match : resolve(cwd, match);
+			for (const file of await filesIn(path)) {
+				files.add(file);
+				matched = true;
+			}
+		}
+		if (!matched) throw new Error(`no files match '${pattern}'`);
+	}
+	return [...files].sort();
+}
+async function filesIn(path) {
+	if (!(await stat(path)).isDirectory()) return [path];
+	return (await readdir(path, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => join(entry.parentPath, entry.name));
+}
+/** `1.2 MB`, `340 kB`, `12 B`. */
+function formatSize(bytes) {
+	const units = [
+		"B",
+		"kB",
+		"MB",
+		"GB"
+	];
+	let size = bytes;
+	let unit = 0;
+	while (size >= 1e3 && unit < units.length - 1) {
+		size /= 1e3;
+		unit++;
+	}
+	return `${unit === 0 ? size : size.toFixed(1)} ${units[unit]}`;
+}
+async function loadJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+//#endregion
+//#region src/components/npm/read.ts
+/**
+* The `packages:` list of a pnpm-workspace.yaml, in block style; negated
+* patterns are left out.
+*/
+function pnpmPackages(text) {
+	const patterns = [];
+	let inPackages = false;
+	for (const line of text.split(/\r?\n/)) {
+		if (/^packages:\s*$/.test(line)) {
+			inPackages = true;
+			continue;
+		}
+		if (!inPackages) continue;
+		const item = /^\s+-\s+(.+?)\s*$/.exec(line);
+		if (item?.[1]) {
+			const pattern = /^(['"])(.*)\1$/.exec(item[1])?.[2] ?? item[1].replace(/\s+#.*$/, "");
+			if (!pattern.startsWith("!")) patterns.push(pattern);
+		} else if (/^\S/.test(line)) inPackages = false;
+	}
+	return patterns;
+}
+/** Globs of the workspace's packages, from pnpm-workspace.yaml or package.json. */
+async function getPackages(cwd) {
+	const pnpm = await readFile(join(cwd, "pnpm-workspace.yaml"), "utf8").catch(() => void 0);
+	if (pnpm !== void 0) {
+		const patterns = pnpmPackages(pnpm);
+		if (patterns.length > 0) return patterns;
+	}
+	const workspaces = (await loadJson(join(cwd, "package.json")).catch(() => ({}))).workspaces;
+	const list = Array.isArray(workspaces) ? workspaces : workspaces?.packages;
+	if (!Array.isArray(list) || list.length === 0) throw new Error("no workspaces: list them in package.json `workspaces`, or in pnpm-workspace.yaml `packages`");
+	return list.filter((item) => typeof item === "string");
+}
+//#endregion
+//#region src/components/npm/workspaces.ts
+const DEPENDENCY_FIELDS$1 = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+/**
+* The packages of an npm, Yarn or pnpm workspace, as components named after
+* them, each depending on the workspace packages it lists as dependencies.
+*/
+const npmWorkspaces = defineComponents({
+	name: "npm/workspaces",
+	description: "Each package of the npm, Yarn or pnpm workspace, named after it and depending on the workspace packages it depends on.",
+	options: {
+		private: z.boolean().default(false).describe("Include packages marked `private`."),
+		exclude: z.array(z.string()).default([]).describe("Packages to leave out, by name.")
+	},
+	create: (options) => ({
+		name: "npm/workspaces",
+		resolve: async (env) => {
+			const patterns = await getPackages(env.cwd);
+			const found = [];
+			for (const pattern of patterns) for await (const match of glob(`${pattern.replace(/\/$/, "")}/package.json`, { cwd: env.cwd })) {
+				const path = match.replaceAll("\\", "/").replace(/\/?package\.json$/, "") || ".";
+				if (path.includes("node_modules")) continue;
+				const json = JSON.parse(await readFile(join(env.cwd, match), "utf8"));
+				if (typeof json.name !== "string") continue;
+				if (json.private === true && !options.private) continue;
+				if (options.exclude.includes(json.name)) continue;
+				if (!found.some((other) => other.path === path)) found.push({
+					name: json.name,
+					path,
+					json
+				});
+			}
+			if (found.length === 0) throw new Error(`no workspace packages in ${env.cwd}`);
+			found.sort((a, b) => a.path.localeCompare(b.path));
+			const names = new Set(found.map(({ name }) => name));
+			return found.map(({ name, path, json }) => {
+				const dependsOn = /* @__PURE__ */ new Set();
+				for (const field of DEPENDENCY_FIELDS$1) {
+					const deps = json[field];
+					if (typeof deps !== "object" || deps === null) continue;
+					for (const dep of Object.keys(deps)) if (names.has(dep) && dep !== name) dependsOn.add(dep);
+				}
+				return {
+					name,
+					path,
+					dependsOn: [...dependsOn]
+				};
+			});
+		}
+	})
+});
+//#endregion
+//#region src/components/index.ts
+var components_exports = /* @__PURE__ */ __exportAll({ npmWorkspaces: () => npmWorkspaces });
+//#endregion
+//#region src/utils/text.ts
+function plural(count, noun, nouns = `${noun}s`) {
+	return `${count} ${count === 1 ? noun : nouns}`;
+}
+/** `a`, `a and b`, `a, b and c`. */
+function joinList(parts) {
+	return parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0] ?? "";
+}
+//#endregion
+//#region src/utils/git.ts
+/** Runs `git` in `cwd` and resolves with its trimmed stdout. */
+function git(cwd, ...args) {
+	return new Promise((resolve, reject) => {
+		execFile("git", args, {
+			cwd,
+			maxBuffer: 67108864
+		}, (error, stdout, stderr) => {
+			if (error) {
+				const detail = stderr.trim() || error.message;
+				reject(/* @__PURE__ */ new Error(`git ${args.join(" ")} failed: ${detail}`));
+			} else resolve(stdout.trim());
+		});
+	});
+}
+/** Like {@link git}, but resolves with `undefined` instead of rejecting. */
+async function tryGit(cwd, ...args) {
+	try {
+		return await git(cwd, ...args);
+	} catch {
+		return;
+	}
+}
+/** `GITHUB_REPOSITORY`, or `owner/repo` from the `origin` remote. */
+async function detectRepo(cwd) {
+	if (process.env.GITHUB_REPOSITORY) return process.env.GITHUB_REPOSITORY;
+	const url = await tryGit(cwd, "remote", "get-url", "origin");
+	return url ? parseGitHubRepo(url) : void 0;
+}
+/** `git@github.com:o/r.git`, `https://github.com/o/r` and similar → `o/r`. */
+function parseGitHubRepo(url) {
+	return /github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?\/?$/.exec(url.trim())?.[1];
+}
+/** Rejects shallow clones, whose history would silently miss commits. */
+async function assertFullHistory(cwd) {
+	if (await git(cwd, "rev-parse", "--is-shallow-repository") === "true") throw new Error("the repository is a shallow clone; fetch full history (e.g. `fetch-depth: 0`)");
+}
+/**
+* `git log` of the commits since `ref` (or all of them), touching a
+* component's pathspec. A component that's the whole project still only
+* counts the commits of the working directory, when that's a subdirectory.
+*/
+async function logSince(cwd, options) {
+	const range = options.ref ? `${options.ref}..HEAD` : "HEAD";
+	let pathspec = options.pathspec;
+	if (pathspec.length === 0) {
+		if (await git(cwd, "rev-parse", "--show-prefix")) pathspec = ["."];
+	}
+	return git(cwd, "log", `--format=${options.format}`, range, ...pathspec.length > 0 ? ["--", ...pathspec] : []);
+}
+/**
+* The oldest commit of the latest run of commits in which `file` had
+* `version`, as `read` finds it in the file's content at each commit; that is,
+* the commit that set the version. `undefined` outside a git repository, or
+* when no commit has it.
+*/
+async function findVersionCommit(cwd, file, version, read) {
+	const log = await tryGit(cwd, "log", "--format=%H", "--", file);
+	if (log === void 0) return void 0;
+	await assertFullHistory(cwd);
+	let found;
+	for (const sha of log.split("\n").filter(Boolean)) {
+		const content = await tryGit(cwd, "show", `${sha}:./${file}`);
+		if (content === void 0 || read(content) !== version) break;
+		found = sha;
+	}
+	return found;
+}
+const BOT_IDENTITY = [
+	"-c",
+	"user.name=github-actions[bot]",
+	"-c",
+	"user.email=41898282+github-actions[bot]@users.noreply.github.com"
+];
+/**
+* Arguments that set the CI's identity when none is set, for commands that
+* commit or tag: the bot's in GitHub Actions, the user who started the
+* pipeline's in GitLab CI.
+*/
+async function identity(cwd) {
+	if (await tryGit(cwd, "config", "user.email")) return [];
+	if (process.env.GITHUB_ACTIONS === "true") return BOT_IDENTITY;
+	const { GITLAB_CI, GITLAB_USER_NAME, GITLAB_USER_EMAIL } = process.env;
+	if (GITLAB_CI === "true" && GITLAB_USER_NAME && GITLAB_USER_EMAIL) return [
+		"-c",
+		`user.name=${GITLAB_USER_NAME}`,
+		"-c",
+		`user.email=${GITLAB_USER_EMAIL}`
+	];
+	return [];
+}
+//#endregion
+//#region src/utils/version.ts
+const PATTERN$1 = /^v?(\d+(?:\.\d+)*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
+/** Parses a version, or returns `undefined` if it isn't one, e.g. `next`. */
+function parseVersion(version) {
+	const match = PATTERN$1.exec(version.trim());
+	if (!match) return void 0;
+	const [, release = "", prerelease, build] = match;
+	return {
+		release: release.split("."),
+		...prerelease !== void 0 && { prerelease },
+		...build !== void 0 && { build }
+	};
+}
+/**
+* Orders versions by precedence: number by number, a missing number counting
+* as 0 (`1.2` = `1.2.0`), then by pre-release as in semver. Build metadata is
+* ignored.
+*/
+function compareVersions(a, b) {
+	for (let i = 0; i < Math.max(a.release.length, b.release.length); i++) {
+		const order = compareNumbers(a.release[i] ?? "0", b.release[i] ?? "0");
+		if (order !== 0) return order;
+	}
+	return comparePrerelease(a.prerelease, b.prerelease);
+}
+/** The index of the first number that differs, or `undefined` if none does. */
+function firstDifference(a, b) {
+	for (let i = 0; i < Math.max(a.release.length, b.release.length); i++) if (compareNumbers(a.release[i] ?? "0", b.release[i] ?? "0") !== 0) return i;
+}
+/** Compares digit strings by value, however long, ignoring leading zeros. */
+function compareNumbers(a, b) {
+	const x = BigInt(a);
+	const y = BigInt(b);
+	return x < y ? -1 : x > y ? 1 : 0;
+}
+function comparePrerelease(a, b) {
+	if (a === b) return 0;
+	if (a === void 0) return 1;
+	if (b === void 0) return -1;
+	const left = a.split(".");
+	const right = b.split(".");
+	for (let i = 0; i < Math.max(left.length, right.length); i++) {
+		const x = left[i];
+		const y = right[i];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		const order = /^\d+$/.test(x) && /^\d+$/.test(y) ? compareNumbers(x, y) : x < y ? -1 : x > y ? 1 : 0;
+		if (order !== 0) return order;
+	}
+	return 0;
+}
+//#endregion
+//#region src/utils/template.ts
+const PLACEHOLDER = /\{(\w+)\}/g;
+/** Replaces `{name}` placeholders, e.g. `v{version}` → `v1.2.3`. */
+function fill(template, values) {
+	return template.replace(PLACEHOLDER, (_, name) => {
+		const value = values[name];
+		if (value === void 0) {
+			const known = Object.keys(values).map((key) => `{${key}}`);
+			throw new Error(`unknown placeholder {${name}} in '${template}'; use ${known.join(" or ")}`);
+		}
+		return value;
+	});
+}
+/**
+* Matches text produced by `fill(template, { [name]: ... })`, capturing the
+* value of `name`, e.g. `v{version}` → `/^v(.+)$/`.
+*/
+function templatePattern(template, name) {
+	let found = false;
+	const source = template.split(PLACEHOLDER).map((part, index) => {
+		if (index % 2 === 0) return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		if (part !== name) throw new Error(`unknown placeholder {${part}} in '${template}'`);
+		found = true;
+		return "(.+)";
+	}).join("");
+	if (!found) throw new Error(`'${template}' has no {${name}} placeholder`);
+	return new RegExp(`^${source}$`);
+}
+const VERSION_PLACEHOLDERS = "`{version}`, `{tag}` and `{name}` (the component's) are filled in, and the scheme's own, e.g. `{major}`, `{minor}` and `{patch}`";
+/**
+* Generic placeholders of a version, in any scheme, under the scheme's own:
+* `2026.01.3` gives `{major}` 2026, `{minor}` 01 and `{patch}` 3. A part the
+* version doesn't have is left out, so using it fails.
+*/
+function versionValues(version) {
+	const [major, minor, patch] = parseVersion(version)?.release ?? [];
+	return Object.fromEntries(Object.entries({
+		version,
+		major,
+		minor,
+		patch
+	}).filter((entry) => entry[1] !== void 0));
+}
+//#endregion
+//#region src/core/channels.ts
+const DEFAULT_FORMATS = {
+	prerelease: "{version}-{channel}.{n}",
+	build: "{version}+{channel}.{n}"
+};
+/** Checks channels, so a typo fails before anything runs. */
+function checkChannels(channels) {
+	const issues = [];
+	for (const [name, channel] of Object.entries(channels)) {
+		const at = `channels.${name}`;
+		if (!/^[0-9A-Za-z-]+$/.test(name)) issues.push(`${at}: names may only have letters, digits and '-'`);
+		if (channel.type !== void 0 && channel.type !== "prerelease" && channel.type !== "build") issues.push(`${at}.type: expected prerelease or build`);
+		const format = channel.format;
+		if (format !== void 0) {
+			for (const name of ["{version}", "{n}"]) if (!format.includes(name)) issues.push(`${at}.format: '${format}' has no ${name} placeholder`);
+			const unknown = [...format.matchAll(/\{(\w+)\}/g)].map(([, name]) => name).find((name) => ![
+				"version",
+				"n",
+				"channel"
+			].includes(name ?? ""));
+			if (unknown) issues.push(`${at}.format: unknown placeholder {${unknown}}; use {version}, {n} or {channel}`);
+		}
+	}
+	if (issues.length > 0) throw new OptionsError(issues);
+}
+/**
+* The channel a run releases on: the one asked for, or the first whose
+* branches match; none means a stable release.
+*/
+function selectChannel(channels, branch, asked) {
+	if (asked !== void 0 && asked !== "") {
+		const channel = channels[asked];
+		if (!channel) {
+			const known = Object.keys(channels);
+			throw new OptionsError([`channel: '${asked}' isn't a channel${known.length > 0 ? `; use ${known.join(", ")}` : "; define it in channels"}`]);
+		}
+		return {
+			name: asked,
+			type: channel.type ?? "prerelease"
+		};
+	}
+	for (const [name, channel] of Object.entries(channels)) if (channel.branches?.some((pattern) => matchesGlob(branch, pattern))) return {
+		name,
+		type: channel.type ?? "prerelease"
+	};
+}
+/** Every channel, with its format for the scheme. */
+function resolveChannels(channels, scheme) {
+	return Object.entries(channels).map(([name, channel]) => {
+		const type = channel.type ?? "prerelease";
+		return {
+			name,
+			type,
+			format: channel.format ?? scheme.formats?.[type] ?? DEFAULT_FORMATS[type]
+		};
+	});
+}
+/**
+* Classifies a version: on one of the channels (`2.0.0-next.3`), stable in
+* the scheme (`2.0.0`), or neither.
+*/
+function classify$1(version, scheme, channels) {
+	for (const channel of channels) {
+		const match = channelPattern(channel).exec(version);
+		const target = match?.groups?.version;
+		const n = match?.groups?.n;
+		if (target !== void 0 && n !== void 0 && scheme.matches(target)) return {
+			type: channel.type,
+			channel: channel.name,
+			target,
+			n: Number(n)
+		};
+	}
+	return scheme.matches(version) ? {
+		type: "stable",
+		target: version
+	} : { type: "foreign" };
+}
+/** A version on a channel. */
+function channelVersion(channel, target, n) {
+	return fill(channel.format, {
+		version: target,
+		channel: channel.name,
+		n: String(n)
+	});
+}
+const RANK$4 = {
+	prerelease: -1,
+	stable: 0,
+	build: 1
+};
+/**
+* Orders classified versions: by target in the scheme, then a prerelease
+* before the stable version before a build, then by counter.
+*/
+function compareClassified(a, b, scheme) {
+	if (a.type === "foreign" || b.type === "foreign") return 0;
+	const order = scheme.compare(a.target, b.target);
+	if (order !== 0) return order;
+	if (a.type !== b.type) return RANK$4[a.type] - RANK$4[b.type];
+	return a.type === "stable" || b.type === "stable" ? 0 : a.n - b.n;
+}
+function channelPattern(channel) {
+	const source = channel.format.split(/(\{\w+\})/).map((part) => {
+		if (part === "{version}") return "(?<version>.+?)";
+		if (part === "{n}") return "(?<n>\\d+)";
+		return (part === "{channel}" ? channel.name : part).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}).join("");
+	return new RegExp(`^${source}$`);
+}
+/** `*` matches within a path segment, `**` across them. */
+function matchesGlob(text, pattern) {
+	const source = pattern.split(/(\*\*|\*)/).map((part) => part === "**" ? ".*" : part === "*" ? "[^/]*" : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("");
+	return new RegExp(`^${source}$`).test(text);
+}
+//#endregion
+//#region src/core/facts.ts
+/** The facts about `changes`, which hold only as long as the changes do. */
+const CHANGE_FIELDS = [
+	"title",
+	"description",
+	"labels",
+	"link"
+];
+function isChangeFact(fact) {
+	return fact.startsWith("changes.");
+}
+/**
+* Throws unless every change has what the facts promise, e.g. `labels` for
+* `changes.labels`. Facts that aren't about changes aren't checked here.
+*/
+function checkChanges(changes, facts) {
+	for (const fact of facts) {
+		const field = CHANGE_FIELDS.find((name) => fact === `changes.${name}`);
+		if (field === void 0) continue;
+		const index = changes.findIndex((change) => change[field] === void 0);
+		if (index !== -1) throw new TypeError(`invalid output: it provides ${fact}, but change ${index} (${changes[index]?.reason}) has no '${field}'`);
+	}
+}
+/** Steps that provide each fact, by name, as they're defined; for error messages. */
+const providers = /* @__PURE__ */ new Map();
+function registerProvider(name, facts) {
+	for (const fact of facts) {
+		const names = providers.get(fact) ?? /* @__PURE__ */ new Set();
+		names.add(name);
+		providers.set(fact, names);
+	}
+}
+/** The defined steps that provide a fact, e.g. to suggest one. */
+function providersOf(fact) {
+	return [...providers.get(fact) ?? []];
+}
+//#endregion
+//#region src/core/reporter.ts
+const ANSI = {
+	bold: [1, 22],
+	dim: [2, 22],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	magenta: [35, 39],
+	cyan: [36, 39]
+};
+/** Aligned, colored output: one row per step with phase, name, duration and reason. */
+function prettyReporter(options = {}) {
+	const write = options.write ?? ((text) => void process.stdout.write(text));
+	const color = options.color ?? (process.env.FORCE_COLOR !== void 0 || process.stdout.isTTY === true && process.env.NO_COLOR === void 0);
+	const paint = (style, text) => color ? `\x1b[${ANSI[style][0]}m${text}\x1b[${ANSI[style][1]}m` : text;
+	let phaseWidth = 0;
+	let nameWidth = 0;
+	let componentWidth = 0;
+	let dryRun = false;
+	return {
+		start(env, steps, components) {
+			dryRun = env.dryRun;
+			phaseWidth = Math.max(0, ...steps.map((step) => step.phase.length));
+			nameWidth = Math.max(0, ...steps.map((step) => step.name.length));
+			componentWidth = components.length > 1 ? Math.max(...components.map((component) => component.name.length)) : 0;
+			const mode = env.dryRun ? paint("yellow", "dry run") : "release";
+			write(`\n${paint("bold", "rylease")} ${mode} ${paint("dim", "·")} ${paint("cyan", env.branch)} ${paint("dim", `· ${env.cwd}`)}\n\n`);
+		},
+		step(record) {
+			const icon = {
+				ok: paint("green", "✔"),
+				skipped: paint("dim", "○"),
+				failed: paint("red", "✖")
+			}[record.status];
+			const phase = paint("magenta", record.phase.padEnd(phaseWidth));
+			const name = paint("bold", record.name.padEnd(nameWidth));
+			const component = componentWidth > 0 ? `${paint("cyan", (record.component ?? "*").padEnd(componentWidth))}  ` : "";
+			const duration = paint("dim", (record.status === "skipped" ? "-" : formatDuration(record.durationMs)).padStart(7));
+			const reason = record.status === "ok" ? record.reason : paint(record.status === "failed" ? "red" : "dim", record.reason);
+			write(`  ${icon} ${component}${phase}  ${name}  ${duration}  ${reason}\n`);
+		},
+		finish(report) {
+			const line = (component) => {
+				const from = component.previousVersion ?? "nothing";
+				const action = component.status === "pending" ? paint("yellow", dryRun ? "would be proposed" : "proposed") : dryRun ? paint("yellow", "would release") : "released";
+				if (component.status !== "released" && component.status !== "pending") return `${paint("bold", from)} ${paint("dim", "·")} nothing to release`;
+				const to = paint("green", paint("bold", component.version ?? "?"));
+				return from === component.version ? `${to} ${paint("dim", "·")} ${action}` : `${paint("bold", from)} → ${to} ${paint("dim", `(${component.kind})`)} ${paint("dim", "·")} ${action}`;
+			};
+			let summary;
+			if (report.status === "failed") summary = paint("red", "release failed");
+			else if (report.components.length === 1 && report.components[0]) summary = line(report.components[0]);
+			else {
+				const width = Math.max(...report.components.map((component) => component.name.length));
+				summary = report.components.map((component) => `${paint("cyan", component.name.padEnd(width))}  ${line(component)}`).join("\n  ");
+			}
+			const deferred = report.deferred === void 0 ? "" : `\n  ${paint("dim", report.deferred)}`;
+			write(`\n  ${summary}${deferred}\n\n`);
+		}
+	};
+}
+function defaultReporter() {
+	return prettyReporter();
+}
+function formatDuration(ms) {
+	if (ms < 1) return "<1ms";
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	return `${(ms / 1e3).toFixed(2)}s`;
+}
+//#endregion
+//#region src/core/types.ts
+/** Every phase, in the order the engine runs its steps. */
+const PHASES = [
+	"read-changes",
+	"determine-kind",
+	"determine-notes",
+	"write",
+	"stage",
+	"release"
+];
+/**
+* How much a release changes, whatever the version scheme: the scheme decides
+* what each kind bumps, e.g. semver's `MAJOR.minor.patch`.
+*/
+const KINDS = [
+	"breaking",
+	"feature",
+	"fix",
+	"none"
+];
+//#endregion
+//#region src/core/engine.ts
+var ReleaseError = class extends Error {
+	report;
+	constructor(message, report, options) {
+		super(message, options);
+		this.name = "ReleaseError";
+		this.report = report;
+	}
+};
+function phaseIndex(phase) {
+	return PHASES.indexOf(phase);
+}
+const KIND_PHASE = phaseIndex("determine-kind");
+/** Phases that must have at least one step for a release to be possible. */
+const REQUIRED_PHASES = PHASES.filter((phase) => phase !== "write" && phase !== "stage" && phase !== "release");
+/** What each phase produces, where later phases read it. */
+const PHASE_VALUES = {
+	"read-changes": "changes",
+	"determine-kind": "kind",
+	"determine-notes": "notes",
+	write: "releases",
+	stage: "releases",
+	release: "releases"
+};
+const CHANGE_FACTS = [
+	"changes.title",
+	"changes.description",
+	"changes.labels",
+	"changes.link"
+];
+/** Stable sort of steps by phase; steps of the same phase keep their order. */
+function sortSteps(steps) {
+	return [...steps].sort((a, b) => phaseIndex(a.phase) - phaseIndex(b.phase));
+}
+async function runRelease(setup, options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const env = {
+		cwd,
+		branch: options.branch ?? await detectBranch(cwd),
+		dryRun: options.dryRun ?? false
+	};
+	const reporter = options.reporter === void 0 ? defaultReporter() : options.reporter;
+	const given = options.release === void 0 ? [] : [options.release].flat();
+	const ordered = sortSteps(setup.steps);
+	const records = [];
+	let states = [];
+	let deferred;
+	const report = (status, error) => {
+		const components = states.map((state) => ({
+			name: state.component.info.name,
+			path: state.component.info.path,
+			status: state.kind === "none" || !state.live ? "unchanged" : status === "failed" ? "failed" : status,
+			dependencies: state.dependencies,
+			releases: state.releases,
+			...definedOnly({
+				previousVersion: state.previousVersion,
+				previousRef: state.previousRef,
+				previousTag: state.previousTag,
+				kind: state.kind,
+				version: state.version,
+				tag: state.tag,
+				notes: state.notes
+			})
+		}));
+		const only = states.length === 1 ? states[0] : void 0;
+		return {
+			env,
+			status,
+			records,
+			components,
+			releases: only?.releases ?? [],
+			...definedOnly({
+				previousVersion: only?.previousVersion,
+				previousRef: only?.previousRef,
+				kind: only?.kind,
+				version: only?.version,
+				notes: only?.notes,
+				deferred,
+				error
+			})
+		};
+	};
+	const record = (entry) => {
+		records.push(entry);
+		reporter?.step?.(entry);
+	};
+	const fail = (error, message = errorMessage(error)) => {
+		const result = report("failed", error);
+		reporter?.finish?.(result);
+		throw new ReleaseError(message, result, { cause: error });
+	};
+	let resolved;
+	try {
+		const channels = setup.channels ?? {};
+		checkChannels(channels);
+		const channel = selectChannel(channels, env.branch, options.channel);
+		if (channel) env.channel = channel;
+		resolved = await resolveSetup(setup, env);
+	} catch (error) {
+		reporter?.start?.(env, ordered, []);
+		return fail(error);
+	}
+	reporter?.start?.(env, [...resolved.flatMap((component) => [...historiesOf(component).map(({ name }) => ({
+		phase: "read-version",
+		name
+	})), {
+		phase: "determine-version",
+		name: component.scheme.name
+	}]), ...ordered], resolved.map(({ info }) => info));
+	states = resolved.map((component) => newState(component, setup.channels ?? {}, env));
+	const missing = given.length > 0 ? [] : REQUIRED_PHASES.filter((phase) => !ordered.some((step) => step.phase === phase));
+	if (missing.length > 0) fail(/* @__PURE__ */ new Error(`no step provided for: ${missing.join(", ")}`));
+	if (given.length > 0) {
+		for (const state of states) state.live = false;
+		for (const release of given) {
+			const target = givenTarget(states, release.component);
+			if (typeof target === "string") fail(new Error(target));
+			const state = target;
+			setGiven(state, release, `releasing the given ${release.version}`);
+			if (release.previousVersion !== void 0) state.facts.add("previousVersion");
+		}
+	} else {
+		for (const state of states) {
+			const start = performance.now();
+			const { scheme } = state.component;
+			try {
+				const found = await findPrevious(state, env);
+				const previous = found.found;
+				const kind = previous?.version === void 0 ? void 0 : classify$1(previous.version, scheme, state.channels);
+				const foreign = kind?.type === "foreign";
+				Object.assign(state, {
+					previousVersion: foreign ? void 0 : previous?.version,
+					previousRef: previous?.ref,
+					previousTag: previous?.tag,
+					stable: previous?.stable?.version ?? (kind?.type === "stable" ? previous?.version : void 0)
+				});
+				if (state.previousVersion !== void 0) state.facts.add("previousVersion");
+				record({
+					phase: "read-version",
+					name: found.name,
+					component: state.component.info.name,
+					status: "ok",
+					durationMs: performance.now() - start,
+					reason: previous ? `${previous.reason}${foreign ? `; ${previous.version} isn't ${scheme.name}, so this release is its first` : ""}` : "no previous release; every change counts",
+					output: previous ?? null
+				});
+				if (previous?.pending) {
+					const pending = previous.pending;
+					setGiven(state, {
+						version: pending.version,
+						...definedOnly({
+							notes: pending.notes,
+							kind: pending.kind,
+							previousVersion: pending.previousVersion
+						})
+					}, `releasing ${pending.version}, ${pending.reason}`);
+				}
+			} catch (error) {
+				record({
+					phase: "read-version",
+					name: historiesOf(state.component).map(({ name }) => name).join(", "),
+					component: state.component.info.name,
+					status: "failed",
+					durationMs: performance.now() - start,
+					reason: errorMessage(error),
+					error
+				});
+				fail(error);
+			}
+		}
+		if (states.some((state) => state.given !== void 0)) for (const state of states.filter((state) => state.given === void 0)) state.live = false;
+	}
+	const publishing = states.find((state) => state.given !== void 0)?.given;
+	const problems = preflight(ordered, states, publishing !== void 0);
+	if (problems.length > 0) fail(new Error(problems.join("\n")));
+	let bumped = publishing !== void 0;
+	if (bumped) setDependencies(states);
+	const skipRest = (from, reason) => {
+		for (const step of ordered.slice(from)) record({
+			phase: step.phase,
+			name: step.name,
+			status: "skipped",
+			durationMs: 0,
+			reason
+		});
+	};
+	const finish = (status) => {
+		const result = report(status);
+		reporter?.finish?.(result);
+		return result;
+	};
+	for (const [index, step] of ordered.entries()) {
+		if (publishing !== void 0 && step.phase !== "release") {
+			record({
+				phase: step.phase,
+				name: step.name,
+				status: "skipped",
+				durationMs: 0,
+				reason: publishing
+			});
+			continue;
+		}
+		if (!bumped && phaseIndex(step.phase) > KIND_PHASE) {
+			bumped = true;
+			await bump(states, env, record, fail);
+			setDependencies(states);
+		}
+		const live = states.filter((state) => state.live);
+		if (live.length === 0) {
+			skipRest(index, "no release-worthy changes");
+			return finish("unchanged");
+		}
+		if (deferred !== void 0 && step.phase === "release") {
+			skipRest(index, deferred);
+			return finish("pending");
+		}
+		const targets = step.scope === "all" ? [void 0] : live;
+		for (const target of targets) {
+			const start = performance.now();
+			const group = target ? [target] : live;
+			const component = target?.component.info.name;
+			try {
+				for (const state of group) assertEarlierPhases(state, step.phase);
+				const input = target ? {
+					...values(target),
+					...shared(env, setup.context, records)
+				} : {
+					components: live.map(values),
+					...shared(env, setup.context, records)
+				};
+				const condition = step.if;
+				if (condition && !condition(input)) {
+					const source = condition.source;
+					record({
+						phase: step.phase,
+						name: step.name,
+						...component !== void 0 && { component },
+						status: "skipped",
+						durationMs: performance.now() - start,
+						reason: source ? `\`${source}\` is false` : "its condition is false"
+					});
+					continue;
+				}
+				for (const state of group) assertNeeds(step, state);
+				const output = await step.run(input);
+				const applied = apply(step, group, target === void 0, output);
+				deferred ??= applied.defer;
+				record({
+					phase: step.phase,
+					name: step.name,
+					...component !== void 0 && { component },
+					status: "ok",
+					durationMs: performance.now() - start,
+					reason: applied.reason,
+					output
+				});
+			} catch (error) {
+				const message = errorMessage(error);
+				record({
+					phase: step.phase,
+					name: step.name,
+					...component !== void 0 && { component },
+					status: "failed",
+					durationMs: performance.now() - start,
+					reason: message,
+					error
+				});
+				skipRest(index + 1, `'${step.phase}' step '${step.name}' failed`);
+				fail(error, `${step.phase} step '${step.name}'${component !== void 0 && states.length > 1 ? ` (${component})` : ""} failed: ${message}`);
+			}
+		}
+	}
+	if (!bumped) {
+		await bump(states, env, record, fail);
+		setDependencies(states);
+	}
+	if (!states.some((state) => state.live)) return finish("unchanged");
+	return finish(deferred !== void 0 ? "pending" : "released");
+}
+async function resolveSetup(setup, env) {
+	const source = setup.components;
+	const components = source === void 0 ? [{ name: "root" }] : "resolve" in source ? await source.resolve(env) : source;
+	const { history } = setup;
+	return resolveComponents(components, {
+		scheme: setup.scheme,
+		history: Array.isArray(history) ? chain(history) : history,
+		tag: setup.tag
+	});
+}
+/** Histories tried in turn; the first that finds a release wins. */
+function chain(histories) {
+	const [only] = histories;
+	if (histories.length === 1 && only) return only;
+	return Object.assign({
+		name: histories.map(({ name }) => name).join(", "),
+		find: async () => void 0
+	}, { chain: histories });
+}
+function historiesOf(component) {
+	const history = component.history;
+	return history.chain ?? [history];
+}
+/** What a history is asked, for a component. */
+function historyInput(state, env) {
+	return {
+		env,
+		component: state.component.info,
+		scheme: state.component.scheme,
+		tag: state.component.tag,
+		channel: state.channel,
+		channels: state.channels
+	};
+}
+async function findPrevious(state, env) {
+	const histories = historiesOf(state.component);
+	for (const history of histories) {
+		const found = await history.find(historyInput(state, env));
+		if (found) return {
+			name: history.name,
+			found
+		};
+	}
+	return {
+		name: histories.map(({ name }) => name).join(", "),
+		found: void 0
+	};
+}
+function newState(component, channels, env) {
+	const resolved = resolveChannels(channels, component.scheme);
+	return {
+		component,
+		previousVersion: void 0,
+		previousRef: void 0,
+		previousTag: void 0,
+		changes: void 0,
+		kind: void 0,
+		exact: void 0,
+		version: void 0,
+		tag: void 0,
+		placeholders: void 0,
+		notes: void 0,
+		dependencies: [],
+		releases: [],
+		facts: new Set(component.scheme.traits ?? []),
+		live: true,
+		stable: void 0,
+		channel: resolved.find(({ name }) => name === env.channel?.name),
+		channels: resolved,
+		given: void 0
+	};
+}
+/** Makes a component release a version worked out before, e.g. by a job. */
+function setGiven(state, release, reason) {
+	const previousVersion = release.previousVersion ?? release.version;
+	state.live = true;
+	state.given = reason;
+	state.previousVersion = previousVersion;
+	state.changes = [];
+	state.kind = release.kind ?? difference(previousVersion, release.version);
+	state.notes = release.notes ?? "";
+	const kind = classify$1(release.version, state.component.scheme, state.channels);
+	setVersion(state, release.version, kind.type === "foreign" ? release.version : kind.target);
+	for (const fact of CHANGE_FACTS) state.facts.add(fact);
+}
+/** Each live component's dependencies released along with it. */
+function setDependencies(states) {
+	for (const state of states.filter((state) => state.live)) state.dependencies = state.component.info.dependsOn.flatMap((name) => {
+		const other = states.find((s) => s.component.info.name === name);
+		return other?.live && other.version !== void 0 && other.kind && other.kind !== "none" ? [{
+			name,
+			version: other.version,
+			...definedOnly({ previousVersion: other.previousVersion }),
+			kind: other.kind
+		}] : [];
+	});
+}
+function givenTarget(states, name) {
+	if (name === void 0) {
+		const [only] = states;
+		return states.length === 1 && only ? only : `there are several components (${names(states)}); say which the given release is for`;
+	}
+	return states.find((state) => state.component.info.name === name) ?? `'${name}' isn't a component; use ${names(states)}`;
+}
+function names(states) {
+	return states.map((state) => state.component.info.name).join(", ");
+}
+/**
+* Sets the version, and what follows from it: the tag and placeholders. On a
+* channel, the scheme's placeholders are its target's.
+*/
+function setVersion(state, version, target = version) {
+	const { component } = state;
+	const tag = fill(component.tag, { version });
+	state.version = version;
+	state.tag = tag;
+	state.placeholders = {
+		...versionValues(target),
+		...component.scheme.matches(target) ? component.scheme.fields?.(target) : {},
+		version,
+		tag,
+		name: component.info.name,
+		...state.channel && { channel: state.channel.name }
+	};
+}
+/**
+* After the last `determine-kind` step: components with nothing to release
+* drop out, and the others get their next version from their scheme, on
+* their channel if there is one.
+*/
+async function bump(states, env, record, fail) {
+	for (const state of states.filter((state) => state.live)) {
+		const start = performance.now();
+		const { scheme, info } = state.component;
+		const base = {
+			phase: "determine-version",
+			name: scheme.name,
+			component: info.name
+		};
+		if (state.kind === void 0) {
+			const error = /* @__PURE__ */ new Error("no 'determine-kind' step ran, so it has no kind");
+			record({
+				...base,
+				status: "failed",
+				durationMs: 0,
+				reason: error.message,
+				error
+			});
+			fail(error);
+		}
+		if (state.kind === "none") {
+			state.live = false;
+			record({
+				...base,
+				status: "skipped",
+				durationMs: 0,
+				reason: "no release-worthy changes"
+			});
+			continue;
+		}
+		const kind = state.kind;
+		const previous = state.previousVersion;
+		try {
+			const next = await nextVersion(state, kind, env);
+			const { version, target } = next;
+			if (!scheme.matches(target)) throw new Error(`${target} isn't a ${scheme.name} version`);
+			if (previous !== void 0) {
+				if (compareClassified(classify$1(version, scheme, state.channels), classify$1(previous, scheme, state.channels), scheme) <= 0) throw new Error(`${version} wouldn't come after ${previous}`);
+			}
+			setVersion(state, version, target);
+			const exists = historiesOf(state.component).find((h) => h.exists);
+			if (state.tag !== void 0 && await exists?.exists?.({
+				...historyInput(state, env),
+				releaseTag: state.tag
+			})) throw new Error(`${state.tag} already exists; it was released from another branch`);
+			record({
+				...base,
+				status: "ok",
+				durationMs: performance.now() - start,
+				reason: previous === void 0 ? `${version}: '${kind}', ${next.how}` : `${version}: '${kind}' from ${previous}, ${next.how}`,
+				output: {
+					version,
+					tag: state.tag
+				}
+			});
+		} catch (error) {
+			record({
+				...base,
+				status: "failed",
+				durationMs: performance.now() - start,
+				reason: errorMessage(error),
+				error
+			});
+			fail(error);
+		}
+	}
+}
+/**
+* The next version, and the scheme's version it stands for: on a
+* prerelease channel, the next stable version's next prerelease (keeping a
+* higher target that its channel already leads up to); on a build channel,
+* the stable version's next build.
+*/
+async function nextVersion(state, kind, env) {
+	const { scheme } = state.component;
+	const channel = state.channel;
+	let target;
+	let how;
+	if (channel?.type === "build") {
+		if (state.stable === void 0) throw new Error(`a build on '${channel.name}' needs a previous release to number builds of`);
+		target = state.stable;
+		how = `build of ${target}`;
+	} else if (state.exact !== void 0) {
+		target = state.exact;
+		how = "as determined";
+	} else {
+		const bumped = scheme.bump({
+			...state.stable !== void 0 && { previous: state.stable },
+			kind,
+			branch: env.branch,
+			date: /* @__PURE__ */ new Date()
+		});
+		target = bumped.version;
+		how = bumped.reason;
+	}
+	if (!channel) return {
+		version: target,
+		target,
+		how
+	};
+	const previous = state.previousVersion === void 0 ? void 0 : classify$1(state.previousVersion, scheme, state.channels);
+	const onChannel = previous !== void 0 && previous.type !== "stable" && previous.type !== "foreign" && previous.channel === channel.name ? previous : void 0;
+	if (channel.type === "prerelease" && onChannel && scheme.compare(onChannel.target, target) > 0) {
+		target = onChannel.target;
+		how = `continues ${target}`;
+	}
+	const counted = await historiesOf(state.component).find((h) => h.count)?.count?.({
+		...historyInput(state, env),
+		target
+	}) ?? 0;
+	const last = onChannel && scheme.compare(onChannel.target, target) === 0 ? onChannel.n : 0;
+	const n = Math.max(counted, last) + 1;
+	return {
+		version: channelVersion(channel, target, n),
+		target,
+		how: `${how}, ${channel.name} ${n}`
+	};
+}
+/**
+* Checks, before anything runs, that every step's needs are met by the
+* scheme and the steps before it, naming steps that would meet them.
+*/
+function preflight(steps, states, given) {
+	const problems = /* @__PURE__ */ new Set();
+	for (const state of states) {
+		const facts = new Set(state.facts);
+		let source;
+		for (const step of steps) {
+			if (given && step.phase !== "release") continue;
+			for (const fact of step.needs ?? []) {
+				if (facts.has(fact)) continue;
+				const by = isChangeFact(fact) ? source === void 0 ? "no step" : source : fact === "previousVersion" ? void 0 : `the scheme ${state.component.scheme.name}`;
+				const providers = providersOf(fact).filter((name) => name !== source);
+				const prefix = states.length > 1 ? `${state.component.info.name}: ` : "";
+				problems.add(by === void 0 ? `${prefix}${step.name} needs a previous ${state.component.scheme.name} version, and there's none` : `${prefix}${step.name} needs ${fact}, which ${by} doesn't provide${providers.length > 0 ? `; ${joinOr(providers)} ${providers.length > 1 ? "do" : "does"}` : ""}`);
+			}
+			if (step.phase === "read-changes" && !step.if) {
+				for (const fact of [...facts]) if (isChangeFact(fact)) facts.delete(fact);
+				source = step.name;
+			}
+			for (const fact of step.provides ?? []) facts.add(fact);
+		}
+	}
+	return [...problems];
+}
+function joinOr(items) {
+	return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} or ${items.at(-1)}`;
+}
+function assertNeeds(step, state) {
+	const missing = (step.needs ?? []).filter((fact) => !state.facts.has(fact));
+	if (missing.length > 0) throw new Error(`it needs ${missing.join(", ")}, which no step that ran provides`);
+}
+function assertEarlierPhases(state, before) {
+	for (const phase of PHASES.slice(0, phaseIndex(before))) if (state[PHASE_VALUES[phase]] === void 0) throw new Error(`no '${phase}' step ran, so it has no ${PHASE_VALUES[phase]}`);
+}
+/** What a step receives for a component. */
+function values(state) {
+	return {
+		component: state.component.info,
+		...definedOnly({
+			previousVersion: state.previousVersion,
+			previousRef: state.previousRef,
+			previousTag: state.previousTag,
+			changes: state.changes,
+			kind: state.kind,
+			version: state.version,
+			tag: state.tag,
+			placeholders: state.placeholders,
+			notes: state.notes
+		}),
+		...state.version !== void 0 && { dependencies: [...state.dependencies] },
+		releases: [...state.releases]
+	};
+}
+function shared(env, context, records) {
+	return {
+		env: { ...env },
+		context,
+		history: [...records]
+	};
+}
+/** Checks a step's output and applies it; resolves with its reason. */
+function apply(step, group, all, value) {
+	const output = checkObject(value);
+	if (step.phase === "write" || step.phase === "stage" || step.phase === "release") {
+		checkRelease(output);
+		if (step.phase !== "release" && output.defer !== void 0) {
+			if (typeof output.defer !== "string" || output.defer.trim() === "") throw new TypeError("invalid output: 'defer' must be a non-empty string when present");
+		}
+		const result = {
+			name: step.name,
+			output: output.output,
+			files: output.files ?? []
+		};
+		for (const state of group) {
+			state.releases.push(result);
+			for (const fact of step.provides ?? []) state.facts.add(fact);
+		}
+		return {
+			reason: output.reason,
+			...typeof output.defer === "string" && { defer: output.defer }
+		};
+	}
+	if (!all) {
+		const [state] = group;
+		if (state) applyTo(step, state, output);
+		return { reason: output.reason };
+	}
+	const results = output.results;
+	if (typeof results !== "object" || results === null || Array.isArray(results)) throw new TypeError("invalid output: 'results' must map components to their results");
+	for (const name of Object.keys(results)) if (!group.some((state) => state.component.info.name === name)) throw new TypeError(`invalid output: '${name}' isn't a component being released`);
+	for (const state of group) {
+		const own = results[state.component.info.name];
+		if (own !== void 0) applyTo(step, state, checkObject(own));
+	}
+	return { reason: output.reason };
+}
+function applyTo(step, state, output) {
+	switch (step.phase) {
+		case "read-changes": {
+			const changes = parseChanges(output);
+			checkChanges(changes, step.provides ?? []);
+			state.changes = changes;
+			for (const fact of [...state.facts]) if (isChangeFact(fact)) state.facts.delete(fact);
+			break;
+		}
+		case "determine-kind":
+			if (!KINDS.includes(output.kind)) throw new TypeError(`invalid output: 'kind' must be one of ${KINDS.join(", ")}`);
+			if (output.version !== void 0 && (typeof output.version !== "string" || output.version === "")) throw new TypeError("invalid output: 'version' must be a non-empty string when present");
+			state.kind = output.kind;
+			state.exact = output.version;
+			break;
+		case "determine-notes":
+			if (typeof output.notes !== "string") throw new TypeError("invalid output: 'notes' must be a string");
+			state.notes = output.notes;
+	}
+	for (const fact of step.provides ?? []) state.facts.add(fact);
+}
+/** Guards against untyped (e.g. plain JS) steps returning malformed output. */
+function checkObject(value) {
+	if (typeof value !== "object" || value === null) throw new TypeError("invalid output: expected an object");
+	const output = value;
+	if (typeof output.reason !== "string" || output.reason.trim() === "") throw new TypeError("invalid output: 'reason' must be a non-empty string");
+	return output;
+}
+function parseChanges(output) {
+	const changes = output.changes;
+	if (!Array.isArray(changes) || !changes.every((change) => typeof change === "object" && change !== null && typeof change.reason === "string")) throw new TypeError("invalid output: 'changes' must be an array of changes, each with a 'reason'");
+	if (!changes.every(({ labels }) => labels === void 0 || Array.isArray(labels) && labels.every((label) => typeof label === "string"))) throw new TypeError("invalid output: a change's 'labels' must be an array of strings when present");
+	return changes;
+}
+function checkRelease(output) {
+	if (!("output" in output)) throw new TypeError("invalid output: 'output' is required (use null for none)");
+	if (output.files !== void 0 && !(Array.isArray(output.files) && output.files.every((file) => typeof file === "string"))) throw new TypeError("invalid output: 'files' must be an array of paths when present");
+}
+/**
+* `breaking` or `feature` when the first or second number differs;
+* otherwise, or when either isn't a version, `fix`.
+*/
+function difference(from, to) {
+	const a = parseVersion(from);
+	const b = parseVersion(to);
+	const index = a && b ? firstDifference(a, b) : void 0;
+	return index === 0 ? "breaking" : index === 1 ? "feature" : "fix";
+}
+async function detectBranch(cwd) {
+	const fromCi = process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || process.env.CI_COMMIT_REF_NAME;
+	if (fromCi) return fromCi;
+	return await tryGit(cwd, "rev-parse", "--abbrev-ref", "HEAD") ?? "unknown";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Drops `undefined` properties, for `exactOptionalPropertyTypes`. */
+function definedOnly(object) {
+	return Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
+}
+//#endregion
+//#region src/core/define.ts
+/**
+* Defines a release pipeline. Pass a custom context type to type the `context`
+* every step receives: `defineRelease<{ slackTs?: string }>({ context: {}, steps })`.
+* Its `scheme` and `history` are its own, or else the preset's its steps come from.
+*/
+function defineRelease(config) {
+	const issues = [];
+	const scheme = config.scheme ?? fromPreset(config.steps, "scheme", issues);
+	const history = config.history ?? fromPreset(config.steps, "history", issues);
+	if (!scheme || !history) throw new OptionsError(issues);
+	return {
+		steps: config.steps,
+		scheme,
+		history,
+		run: (options) => runRelease({
+			steps: config.steps,
+			context: config.context,
+			scheme,
+			tag: config.tag,
+			history,
+			components: config.components,
+			channels: config.channels
+		}, options)
+	};
+}
+const EXAMPLES = {
+	scheme: "semver",
+	history: "git/tags"
+};
+/** The scheme or history provided by the one preset `steps` come from that has it. */
+function fromPreset(steps, key, issues) {
+	const provided = /* @__PURE__ */ new Map();
+	for (const { preset } of steps) if (preset?.[key] && !provided.has(preset.name)) provided.set(preset.name, preset[key]);
+	const [only, ...others] = provided.values();
+	if (only && others.length === 0) return only;
+	issues.push(provided.size === 0 ? `${key}: expected one, e.g. ${EXAMPLES[key]}, or a preset that provides one` : `${key}: ${joinList([...provided.keys()])} each provide one; set it`);
+}
+/**
+* Defines a reusable step whose options are declared as a zod shape. The
+* result is a factory: call it with options to get a step. Its options are
+* validated on every call, so they're just as safe when they come from a
+* workflow file.
+*
+* ```ts
+* export const header = defineStep({
+*   phase: "determine-notes",
+*   name: "header",
+*   options: { text: z.string().default("Released by rylease") },
+*   run: ({ notes, options }) => ({ notes: `> ${options.text}\n\n${notes}`, reason: "added header" }),
+* });
+* header({ text: "Hi" });
+* ```
+*/
+function defineStep(definition) {
+	const shape = definition.options ?? {};
+	const scope = definition.scope ?? "each";
+	const declared = definition.needs ?? [];
+	const needs = typeof declared === "function" ? [] : declared;
+	const provides = definition.provides ?? [];
+	for (const key of ["phase", "name"]) if (!(key in definition)) throw new OptionsError([`${definition.name}: ${key} is required`]);
+	registerProvider(definition.name, provides);
+	const factory = (options) => {
+		const parsed = parseOptions(shape, options, definition.name);
+		const run = definition.run;
+		const needs = typeof declared === "function" ? declared(parsed) : declared;
+		return {
+			phase: typeof definition.phase === "function" ? definition.phase(parsed) : definition.phase,
+			name: definition.name,
+			...scope === "all" && { scope },
+			...needs.length > 0 && { needs },
+			...provides.length > 0 && { provides },
+			run: (input) => run({
+				...input,
+				options: parsed
+			})
+		};
+	};
+	return Object.defineProperties(factory, {
+		kind: {
+			value: "step",
+			enumerable: true
+		},
+		phase: {
+			value: definition.phase,
+			enumerable: true
+		},
+		name: {
+			value: definition.name,
+			enumerable: true
+		},
+		description: {
+			value: definition.description,
+			enumerable: true
+		},
+		scope: {
+			value: scope,
+			enumerable: true
+		},
+		needs: {
+			value: needs,
+			enumerable: true
+		},
+		provides: {
+			value: provides,
+			enumerable: true
+		},
+		options: {
+			value: shape,
+			enumerable: true
+		}
+	});
+}
+/**
+* Bundles step factories under one name. Calling the preset creates every
+* step, passing each its options by name:
+* `conventional({ "github/create-release": false, "conventional/determine-kind": { fallback: "none" } })`.
+* `defaults` sets the preset's own options per step, under the caller's;
+* `scheme` and `history` make the release's, unless it sets its own, e.g.
+* `history: gitTags` for a preset that tags its releases.
+*/
+function definePreset(definition) {
+	const names = definition.steps.map((step) => step.name);
+	const defaults = definition.defaults ?? {};
+	const preset = (options = {}) => {
+		const unknown = Object.keys(options).filter((key) => !names.includes(key));
+		if (unknown.length > 0) throw new OptionsError(unknown.map((key) => `${definition.name}: '${key}' isn't one of its steps (${names.join(", ")})`));
+		const made = {
+			name: definition.name,
+			...definition.scheme && { scheme: definition.scheme() },
+			...definition.history && { history: definition.history() }
+		};
+		return definition.steps.flatMap((factory) => {
+			const value = options[factory.name];
+			if (value === false) return [];
+			const base = defaults[factory.name];
+			const merged = base && (value == null || typeof value === "object") ? {
+				...base,
+				...value
+			} : value;
+			try {
+				return [{
+					...factory(merged),
+					preset: made
+				}];
+			} catch (error) {
+				throw error instanceof OptionsError ? new OptionsError(error.issues.map((issue) => `${definition.name}.${issue}`)) : error;
+			}
+		});
+	};
+	return Object.defineProperties(preset, {
+		kind: {
+			value: "preset",
+			enumerable: true
+		},
+		name: {
+			value: definition.name,
+			enumerable: true
+		},
+		description: {
+			value: definition.description,
+			enumerable: true
+		},
+		steps: {
+			value: definition.steps,
+			enumerable: true
+		},
+		defaults: {
+			value: definition.defaults ?? {},
+			enumerable: true
+		},
+		scheme: {
+			value: definition.scheme,
+			enumerable: true
+		},
+		history: {
+			value: definition.history,
+			enumerable: true
+		}
+	});
+}
+/**
+* Makes a step run only when `condition` holds, on top of any condition it
+* already has: `when(steps.npmPublish(), ({ env }) => !env.dryRun)`.
+*/
+function when(step, condition) {
+	const own = step.if;
+	const source = condition.source ?? "its condition";
+	const combined = own ? Object.assign((input) => condition(input) && own(input), { source: `${source} && ${own.source ?? "its own condition"}` }) : condition;
+	return {
+		...step,
+		if: combined
+	};
+}
+//#endregion
+//#region src/core/expression.ts
+const NAMES = [
+	"dryRun",
+	"branch",
+	"cwd",
+	"channel",
+	"prerelease",
+	"component",
+	"components",
+	"previousVersion",
+	"previousRef",
+	"previousTag",
+	"changes",
+	"kind",
+	"version",
+	"tag",
+	"notes",
+	"dependencies",
+	"steps"
+];
+const VALUES = [
+	"previousVersion",
+	"previousRef",
+	"previousTag",
+	"changes",
+	"kind",
+	"version",
+	"tag",
+	"notes",
+	"dependencies"
+];
+/** Values of a component, as expressions read them. */
+function valuesOf(results) {
+	const component = results.component;
+	return {
+		...component && { component: {
+			name: component.name,
+			path: component.path
+		} },
+		...Object.fromEntries(VALUES.flatMap((name) => results[name] === void 0 ? [] : [[name, results[name]]]))
+	};
+}
+/** What an expression reads, from what a step receives: for one component, or all. */
+function expressionContext(input) {
+	const fields = input;
+	const own = fields.component;
+	const all = fields.components;
+	return {
+		dryRun: fields.env.dryRun,
+		branch: fields.env.branch,
+		cwd: fields.env.cwd,
+		channel: fields.env.channel?.name ?? null,
+		prerelease: fields.env.channel?.type === "prerelease",
+		...all ? {
+			components: all.map(valuesOf),
+			...all.length === 1 && all[0] ? valuesOf(all[0]) : {}
+		} : valuesOf(fields),
+		steps: Object.fromEntries(fields.history.filter((record) => record.phase !== "read-version" && record.phase !== "determine-version" && (record.component === void 0 || own === void 0 || record.component === own.name)).map((record) => [record.name, {
+			phase: record.phase,
+			status: record.status,
+			reason: record.reason,
+			output: record.phase === "release" ? record.output?.output : record.output
+		}]))
+	};
+}
+var ExpressionError = class extends Error {
+	name = "ExpressionError";
+};
+const FUNCTIONS = {
+	contains: (search, item) => Array.isArray(search) ? search.includes(item) : String(search ?? "").includes(String(item ?? "")),
+	startsWith: (text, prefix) => String(text ?? "").startsWith(String(prefix ?? "")),
+	endsWith: (text, suffix) => String(text ?? "").endsWith(String(suffix ?? ""))
+};
+const TOKEN = /\s*(?:(\d+(?:\.\d+)?)|'((?:[^']|'')*)'|([A-Za-z_][\w-]*)|(==|!=|<=|>=|&&|\|\||[!<>().[\],]))/y;
+function tokenize(source) {
+	const tokens = [];
+	TOKEN.lastIndex = 0;
+	while (source.slice(TOKEN.lastIndex).trim() !== "") {
+		const at = TOKEN.lastIndex;
+		const match = TOKEN.exec(source);
+		if (!match) {
+			const rest = source.slice(at).trimStart();
+			const hint = rest[0] === "/" ? "; read names with '/' as steps['git/commit']" : "";
+			throw new ExpressionError(`unexpected '${rest[0]}' at ${source.length - rest.length + 1}${hint}`);
+		}
+		const [, number, string, name, op] = match;
+		if (number !== void 0) tokens.push({
+			kind: "number",
+			value: Number(number)
+		});
+		else if (string !== void 0) tokens.push({
+			kind: "string",
+			value: string.replaceAll("''", "'")
+		});
+		else if (name !== void 0) tokens.push({
+			kind: "name",
+			value: name
+		});
+		else tokens.push({
+			kind: "op",
+			value: op ?? ""
+		});
+	}
+	return tokens;
+}
+/**
+* Compiles an `if:` expression, in the style of GitHub's: literals (`true`,
+* `'text'`, `1`, `null`), names from {@link ExpressionContext} with `.x` and
+* `['x']` access, `!`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&&`, `||`,
+* parentheses, and `contains`, `startsWith` and `endsWith`.
+*/
+function compileExpression(source) {
+	const tokens = tokenize(source);
+	let position = 0;
+	const peek = () => tokens[position];
+	const isOp = (value) => {
+		const token = peek();
+		return token?.kind === "op" && token.value === value;
+	};
+	const expect = (value) => {
+		if (!isOp(value)) throw unexpected();
+		position++;
+	};
+	const unexpected = () => {
+		const token = peek();
+		return new ExpressionError(token ? `unexpected '${token.value}'` : "unexpected end");
+	};
+	const binary = (next, operators) => {
+		return () => {
+			let left = next();
+			for (;;) {
+				const token = peek();
+				const apply = token?.kind === "op" ? operators[token.value] : void 0;
+				if (!apply) return left;
+				position++;
+				const right = next();
+				const l = left;
+				left = (context) => apply(l(context), () => right(context));
+			}
+		};
+	};
+	const compare = (test) => (a, b) => {
+		const right = b();
+		return (typeof a === "number" || typeof a === "string") && typeof right === typeof a && test(a, right);
+	};
+	const primary = () => {
+		const token = peek();
+		if (!token) throw unexpected();
+		position++;
+		if (token.kind === "number" || token.kind === "string") return () => token.value;
+		if (token.kind === "op") {
+			if (token.value === "!") {
+				const operand = primary();
+				return (context) => !operand(context);
+			}
+			if (token.value === "(") {
+				const inner = or();
+				expect(")");
+				return inner;
+			}
+			position--;
+			throw unexpected();
+		}
+		const literals = {
+			true: true,
+			false: false,
+			null: null
+		};
+		if (token.value in literals) return () => literals[token.value];
+		if (isOp("(")) {
+			const fn = FUNCTIONS[token.value];
+			if (!fn) throw new ExpressionError(`unknown function '${token.value}'; use ${Object.keys(FUNCTIONS).join(", ")}`);
+			position++;
+			const args = [];
+			if (!isOp(")")) {
+				args.push(or());
+				while (isOp(",")) {
+					position++;
+					args.push(or());
+				}
+			}
+			expect(")");
+			return (context) => fn(...args.map((arg) => arg(context)));
+		}
+		if (!NAMES.includes(token.value)) throw new ExpressionError(`unknown name '${token.value}'; use ${NAMES.join(", ")}`);
+		const name = token.value;
+		let node = (context) => context[name];
+		for (;;) if (isOp(".")) {
+			position++;
+			const key = peek();
+			if (key?.kind !== "name") throw unexpected();
+			position++;
+			const object = node;
+			node = (context) => property(object(context), key.value);
+		} else if (isOp("[")) {
+			position++;
+			const key = or();
+			expect("]");
+			const object = node;
+			node = (context) => property(object(context), key(context));
+		} else return node;
+	};
+	const or = binary(binary(binary(binary(primary, {
+		"<": compare((a, b) => a < b),
+		"<=": compare((a, b) => a <= b),
+		">": compare((a, b) => a > b),
+		">=": compare((a, b) => a >= b)
+	}), {
+		"==": (a, b) => (a ?? null) === (b() ?? null),
+		"!=": (a, b) => (a ?? null) !== (b() ?? null)
+	}), { "&&": (a, b) => a ? b() : a }), { "||": (a, b) => a || b() });
+	if (tokens.length === 0) throw new ExpressionError("empty expression");
+	const root = or();
+	if (position < tokens.length) throw unexpected();
+	return root;
+}
+function property(object, key) {
+	if (typeof object !== "object" || object === null) return void 0;
+	const name = String(key);
+	return Object.hasOwn(object, name) ? object[name] : void 0;
+}
+//#endregion
+//#region src/core/history.ts
+/** Defines where previous releases are found, with options as a zod shape. */
+function defineHistory(definition) {
+	return makeFactory("history", definition);
+}
+//#endregion
+//#region src/steps/npm/package-json.ts
+function versionOf(json, source) {
+	if (typeof json.version !== "string" || json.version === "") throw new Error(`${source} has no 'version'`);
+	return json.version;
+}
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+/**
+* A package.json's text with a new `version`, and with dependencies on the
+* given packages pointed at theirs, keeping each range's operator (`^`, `~`,
+* `>=` or none). `workspace:`, `file:` and ranges like `1.x` are left for the
+* package manager. Its indentation and trailing newline are kept.
+*/
+function setPackageJsonVersion(text, version, packages) {
+	const json = JSON.parse(text);
+	json.version = version;
+	const changed = [];
+	for (const field of DEPENDENCY_FIELDS) {
+		const deps = json[field];
+		if (typeof deps !== "object" || deps === null) continue;
+		for (const [name, range] of Object.entries(deps)) {
+			const next = packages.get(name);
+			if (next === void 0 || typeof range !== "string") continue;
+			const updated = withOperator(range, next);
+			if (updated === void 0 || updated === range) continue;
+			deps[name] = updated;
+			changed.push(`${name}@${updated}`);
+		}
+	}
+	const indent = /^[ \t]+(?=")/m.exec(text)?.[0] ?? "	";
+	const newline = text.endsWith("\n") ? "\n" : "";
+	return {
+		text: JSON.stringify(json, null, indent) + newline,
+		dependencies: [...new Set(changed)]
+	};
+}
+/**
+* A range pointed at a new version, keeping its operator, or `undefined`
+* when it isn't a plain range on one version.
+*/
+function withOperator(range, version) {
+	const match = /^(\^|~|>=|=)?v?\d+(?:\.\d+)*(?:[-+][0-9A-Za-z.+-]+)?$/.exec(range.trim());
+	return match ? `${match[1] ?? ""}${version}` : void 0;
+}
+//#endregion
+//#region src/steps/fs/formats.ts
+const FORMAT_NAMES = [
+	"plain",
+	"npm",
+	"cargo",
+	"python",
+	"helm",
+	"gradle",
+	"maven",
+	"pattern"
+];
+/** The format by name; `pattern` needs its template, e.g. `VERSION = "{version}"`. */
+function versionFormat(name, pattern) {
+	switch (name) {
+		case "plain": return plain;
+		case "npm": return npm;
+		case "cargo": return cargo;
+		case "python": return python;
+		case "helm": return helm;
+		case "gradle": return gradle;
+		case "maven": return maven;
+		case "pattern":
+			if (pattern === void 0) throw new Error("the pattern format needs a `pattern`");
+			return fromPattern(pattern);
+	}
+}
+const unchanged = (text) => ({
+	text,
+	dependencies: []
+});
+const plain = {
+	name: "plain",
+	path: "VERSION",
+	read: (text) => text.trim() || void 0,
+	write: (text, version) => unchanged(`${version}${text === "" || text.endsWith("\n") ? "\n" : ""}`)
+};
+const npm = {
+	name: "npm",
+	path: "package.json",
+	needs: ["version.semver"],
+	read: (text) => {
+		const json = parseJson(text);
+		return typeof json?.version === "string" && json.version !== "" ? json.version : void 0;
+	},
+	write: setPackageJsonVersion,
+	packageName: (text) => {
+		const name = parseJson(text)?.name;
+		return typeof name === "string" ? name : void 0;
+	}
+};
+function parseJson(text) {
+	try {
+		const json = JSON.parse(text);
+		return typeof json === "object" && json !== null ? json : void 0;
+	} catch {
+		return;
+	}
+}
+/** `key = "value"` in the first of the TOML tables that has it. */
+function tomlKey(tables, key) {
+	const find = (text) => {
+		const lines = text.split("\n");
+		for (const table of tables) {
+			let inside = false;
+			for (const [index, line] of lines.entries()) {
+				const header = /^\s*\[([^[\]]+)\]\s*(#.*)?$/.exec(line);
+				if (header) {
+					inside = header[1]?.trim() === table;
+					continue;
+				}
+				if (/^\s*\[\[/.test(line)) {
+					inside = false;
+					continue;
+				}
+				const match = new RegExp(`^(\\s*${key}\\s*=\\s*)(["'])([^"']*)\\2(.*)$`).exec(line);
+				if (inside && match) return {
+					lines,
+					index,
+					match
+				};
+			}
+		}
+	};
+	return {
+		read: (text) => find(text)?.match[3],
+		write: (text, value) => {
+			const found = find(text);
+			if (!found) return void 0;
+			const [, before, quote, , after] = found.match;
+			found.lines[found.index] = `${before}${quote}${value}${quote}${after}`;
+			return found.lines.join("\n");
+		}
+	};
+}
+const CARGO_TABLES = [
+	"dependencies",
+	"dev-dependencies",
+	"build-dependencies",
+	"workspace.dependencies"
+];
+const cargoVersion = tomlKey(["package", "workspace.package"], "version");
+const cargoName = tomlKey(["package"], "name");
+const cargo = {
+	name: "cargo",
+	path: "Cargo.toml",
+	needs: ["version.semver"],
+	read: cargoVersion.read,
+	write: (text, version, packages) => {
+		const written = cargoVersion.write(text, version);
+		if (written === void 0) throw new Error("it has no [package] version");
+		const dependencies = [];
+		let table = "";
+		return {
+			text: written.split("\n").map((line) => {
+				const header = /^\s*\[([^[\]]+)\]/.exec(line);
+				if (header) table = header[1]?.trim() ?? "";
+				if (!CARGO_TABLES.some((name) => table.endsWith(name))) return line;
+				const match = /^(\s*"?([\w-]+)"?\s*=\s*\{[^}]*\bversion\s*=\s*")([^"]*)(".*)$/.exec(line);
+				const next = match?.[2] ? packages.get(match[2]) : void 0;
+				const range = match?.[3];
+				if (!match || next === void 0 || range === void 0) return line;
+				const updated = withOperator(range, next);
+				if (updated === void 0 || updated === range) return line;
+				dependencies.push(`${match[2]}@${updated}`);
+				return `${match[1]}${updated}${match[4]}`;
+			}).join("\n"),
+			dependencies
+		};
+	},
+	packageName: cargoName.read
+};
+const pythonVersion = tomlKey(["project", "tool.poetry"], "version");
+const python = {
+	name: "python",
+	path: "pyproject.toml",
+	read: pythonVersion.read,
+	write: (text, version) => {
+		const written = pythonVersion.write(text, version);
+		if (written === void 0) throw new Error("it has no [project] or [tool.poetry] version");
+		return unchanged(written);
+	}
+};
+/** A top-level `key: value` line, e.g. in YAML or a properties file. */
+function lineKey(name, path, pattern) {
+	return {
+		name,
+		path,
+		read: (text) => pattern.exec(text)?.[3],
+		write: (text, version) => {
+			if (!pattern.test(text)) throw new Error(`it has no ${name} version`);
+			return unchanged(text.replace(pattern, (_, before, quote, __, after) => `${before}${quote}${version}${quote}${after}`));
+		}
+	};
+}
+const helm = lineKey("helm", "Chart.yaml", /^(version:\s*)(["']?)([^"'\s#]+)\2(.*)$/m);
+const gradle = lineKey("gradle", "gradle.properties", /^(\s*version\s*[=:]\s*)()([^\s#]+)()$/m);
+/** The project's own `<version>`: the one directly in `<project>`. */
+function mavenVersion(text) {
+	const tags = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<(\/?)([\w.:-]+)[^>]*?(\/?)>/g;
+	let depth = 0;
+	let open;
+	for (const match of text.matchAll(tags)) {
+		const [whole, closing, name, selfClosing] = match;
+		if (name === void 0 || selfClosing) continue;
+		if (closing) {
+			depth--;
+			if (name === "version" && depth === 1 && open !== void 0) return {
+				start: open,
+				end: match.index
+			};
+			continue;
+		}
+		if (name === "version" && depth === 1) open = match.index + whole.length;
+		depth++;
+	}
+}
+const maven = {
+	name: "maven",
+	path: "pom.xml",
+	read: (text) => {
+		const found = mavenVersion(text);
+		return found ? text.slice(found.start, found.end).trim() : void 0;
+	},
+	write: (text, version) => {
+		const found = mavenVersion(text);
+		if (!found) throw new Error("it has no project <version>");
+		return unchanged(`${text.slice(0, found.start)}${version}${text.slice(found.end)}`);
+	}
+};
+/**
+* Versions wherever a template matches, e.g. `__version__ = "{version}"`;
+* every match is written.
+*/
+function fromPattern(template) {
+	if (!template.includes("{version}")) throw new Error(`the pattern '${template}' has no {version} placeholder`);
+	const source = template.split("{version}").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("([^\\s\"'`,;<>]+)");
+	const pattern = new RegExp(source, "g");
+	return {
+		name: "pattern",
+		path: "",
+		read: (text) => new RegExp(source).exec(text)?.[1],
+		write: (text, version) => {
+			if (!new RegExp(source).test(text)) throw new Error(`nothing matches '${template}'`);
+			return unchanged(text.replace(pattern, () => template.replaceAll("{version}", version)));
+		}
+	};
+}
+//#endregion
+//#region src/histories/fs/version-file.ts
+/**
+* Finds the previous release in the project's version file: the version in
+* it, released at the commit that set it. For projects that kept their
+* version in a file before tagging releases, like `package.json` or a
+* `VERSION` file.
+*/
+const fsVersionFile = defineHistory({
+	name: "fs/version-file",
+	description: "The version in the project's version file, in any format `fs/write-version` writes, released at the commit that set it.",
+	options: {
+		format: z.enum(FORMAT_NAMES).default("plain").describe("As for `fs/write-version`."),
+		path: z.string().optional().describe("Relative to the component's directory; defaults to the format's file."),
+		pattern: z.string().optional().describe("With the `pattern` format, where the version is.")
+	},
+	create: (options) => {
+		const format = versionFormat(options.format, options.pattern);
+		const path = options.path ?? format.path;
+		if (path === "") throw new Error("the pattern format needs a `path`");
+		return {
+			name: "fs/version-file",
+			find: async ({ env, component }) => {
+				const dir = join(env.cwd, component.path);
+				const shown = join(component.path, path).replaceAll("\\", "/");
+				const version = format.read(await readFile(join(dir, path), "utf8"));
+				if (version === void 0) throw new Error(`${shown} has no version`);
+				const ref = await findVersionCommit(dir, path, version, format.read);
+				return {
+					version,
+					...ref && { ref },
+					reason: ref ? `${version} in ${shown}, set in ${ref.slice(0, 7)}` : `${version} in ${shown}, not in git history`
+				};
+			}
+		};
+	}
+});
+//#endregion
+//#region src/histories/git/git-tags.ts
+const FIELD = "";
+/**
+* Finds the previous release by its tag: the nearest on HEAD. Of the release
+* tags merged into HEAD, only those that no other one comes after count, so
+* a `1.x` branch finds its own latest release, not `main`'s; of those, the
+* highest version in the scheme wins. When the scheme changed since, the
+* nearest release still marks where changes start, but there's no previous
+* version to bump: the release is the scheme's first.
+*
+* A stable release only counts stable releases. On a channel, its own
+* releases count too, and the nearest stable release is what's bumped.
+*/
+const gitTags = defineHistory({
+	name: "git/tags",
+	description: "The nearest release tag on HEAD: the highest version among the tags no other release tag comes after. On a channel, its own releases count too.",
+	create: () => ({
+		name: "git/tags",
+		find: async (input) => {
+			const cwd = input.env.cwd;
+			if (await tryGit(cwd, "rev-parse", "--verify", "--quiet", "HEAD") === void 0) return;
+			await assertFullHistory(cwd);
+			const tags = await listTags(input, true);
+			const channel = input.channel?.name;
+			const counts = (tag) => tag.kind.type === "stable" || tag.kind.type === "foreign" || tag.kind.channel === channel;
+			const best = await nearest(cwd, tags.filter(counts), input);
+			if (!best) return void 0;
+			const at = `${best.name} at ${best.commit.slice(0, 7)}`;
+			if (best.kind.type === "foreign") return {
+				ref: best.commit,
+				tag: best.name,
+				reason: `${at}, nearest on HEAD; not ${input.scheme.name}, so this release is its first`
+			};
+			const stable = best.kind.type === "stable" ? void 0 : await nearest(cwd, tags.filter((tag) => tag.kind.type === "stable"), input);
+			return {
+				version: best.version,
+				ref: best.commit,
+				tag: best.name,
+				reason: `${at}, nearest on HEAD${stable ? `; ${stable.version} before it` : ""}`,
+				...stable && { stable: {
+					version: stable.version,
+					ref: stable.commit,
+					tag: stable.name
+				} }
+			};
+		},
+		count: async (input) => {
+			const channel = input.channel?.name;
+			let highest = 0;
+			for (const { kind } of await listTags(input, false)) if (kind.type !== "stable" && kind.type !== "foreign" && kind.channel === channel && input.scheme.compare(kind.target, input.target) === 0) highest = Math.max(highest, kind.n);
+			return highest;
+		},
+		exists: async ({ env, releaseTag }) => await tryGit(env.cwd, "rev-parse", "--verify", "--quiet", `refs/tags/${releaseTag}`) !== void 0
+	})
+});
+/** Release tags, of HEAD or of the whole repository, classified. */
+async function listTags(input, merged) {
+	const pattern = templatePattern(input.tag, "version");
+	const listing = await git(input.env.cwd, "for-each-ref", ...merged ? ["--merged=HEAD"] : [], `--format=%(refname:strip=2)${FIELD}%(objectname)${FIELD}%(*objectname)${FIELD}%(creatordate:unix)`, "refs/tags");
+	const tags = [];
+	for (const line of listing.split("\n").filter(Boolean)) {
+		const [name = "", object = "", peeled = "", date = "0"] = line.split(FIELD);
+		const version = pattern.exec(name)?.[1];
+		if (version === void 0) continue;
+		const kind = classify$1(version, input.scheme, input.channels);
+		if (kind.type === "foreign" && parseVersion(version) === void 0) continue;
+		tags.push({
+			name,
+			version,
+			commit: peeled || object,
+			date: Number(date),
+			kind
+		});
+	}
+	return tags;
+}
+/**
+* The nearest of the tags: of those no other one comes after, the highest
+* in the scheme, or failing that, the latest of another scheme.
+*/
+async function nearest(cwd, tags, input) {
+	if (tags.length === 0) return void 0;
+	const commits = [...new Set(tags.map((tag) => tag.commit))];
+	const frontier = new Set(commits.length === 1 ? commits : (await git(cwd, "merge-base", "--independent", ...commits)).split("\n"));
+	const near = tags.filter((tag) => frontier.has(tag.commit));
+	const ours = near.filter((tag) => tag.kind.type !== "foreign");
+	return ours.length > 0 ? ours.reduce((a, b) => compareClassified(b.kind, a.kind, input.scheme) > 0 ? b : a) : near.reduce((a, b) => b.date > a.date ? b : a);
+}
+//#endregion
+//#region src/utils/retry.ts
+/** Waits; replaceable in tests. */
+const clock = { sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)) };
+/** Calls `run` until it resolves, waiting longer before each retry. */
+async function retry(run, options) {
+	const delayMs = options.delayMs ?? ((retry) => retry * 1e3);
+	for (let attempt = 1;; attempt++) try {
+		return await run(attempt);
+	} catch (error) {
+		if (attempt >= options.attempts || !(options.retryIf?.(error) ?? true)) throw error;
+		await clock.sleep(delayMs(attempt));
+	}
+}
+/**
+* Polls `check` until it resolves with a value, e.g. until something another
+* job created becomes visible; resolves with `undefined` if it never does.
+*/
+async function waitFor(check, options) {
+	try {
+		return await retry(async () => {
+			const value = await check();
+			if (value === void 0) throw new NotYet();
+			return value;
+		}, {
+			...options,
+			retryIf: (error) => error instanceof NotYet
+		});
+	} catch (error) {
+		if (error instanceof NotYet) return void 0;
+		throw error;
+	}
+}
+var NotYet = class extends Error {};
+//#endregion
+//#region src/steps/github/api.ts
+/** The token option, `GITHUB_TOKEN` or `GH_TOKEN`. */
+function githubToken(token) {
+	const found = token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+	if (!found) throw new Error("no token; set GITHUB_TOKEN or GH_TOKEN");
+	return found;
+}
+var GitHubError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "GitHubError";
+		this.status = status;
+	}
+};
+/** Statuses worth another try: rate limits and server errors. */
+function isTransient(error) {
+	if (error instanceof GitHubError) return error.status === 429 || error.status >= 500;
+	return error instanceof TypeError;
+}
+/** A GitHub REST client for one repository that retries transient failures. */
+function githubClient(repo, token) {
+	const apiUrl = process.env.GITHUB_API_URL ?? "https://api.github.com";
+	return {
+		repo,
+		request: (method, path, options = {}) => retry(async () => {
+			const url = /^https?:/.test(path) ? path : `${apiUrl}/repos/${repo}${path}`;
+			const response = await fetch(url, {
+				method,
+				headers: {
+					accept: "application/vnd.github+json",
+					authorization: `Bearer ${token}`,
+					"x-github-api-version": "2022-11-28",
+					...options.body !== void 0 && { "content-type": options.contentType ?? "application/json" }
+				},
+				...options.body !== void 0 && { body: options.contentType === void 0 ? JSON.stringify(options.body) : options.body }
+			});
+			const text = await response.text();
+			if (!response.ok && !options.allow?.includes(response.status)) {
+				const wait = Number(response.headers.get("retry-after"));
+				if (response.status === 429 && wait > 0) await clock.sleep(Math.min(wait, 60) * 1e3);
+				throw new GitHubError(response.status, `GitHub responded ${response.status} to ${method} ${url}: ${text}`);
+			}
+			return {
+				status: response.status,
+				data: text ? JSON.parse(text) : null
+			};
+		}, {
+			attempts: options.attempts ?? 5,
+			retryIf: isTransient
+		})
+	};
+}
+//#endregion
+//#region src/steps/github/release.ts
+/** The `repo` option, or the repository being released. */
+async function releaseRepo(cwd, repo) {
+	const found = repo ?? await detectRepo(cwd);
+	if (!found) throw new Error("couldn't determine the GitHub repository; set `repo` or GITHUB_REPOSITORY");
+	return found;
+}
+/** Options of the steps that create a release, or find one. */
+const releaseOptions = {
+	title: z.string().default("{tag}").describe("`{tag}`, `{version}`, `{name}` and the scheme's placeholders are filled in."),
+	draft: z.boolean().default(false),
+	prerelease: z.union([z.boolean(), z.literal("auto")]).default("auto").describe("`auto` marks releases on a prerelease channel."),
+	repo: z.string().optional().describe("`owner/repo`; defaults to `GITHUB_REPOSITORY` or the `origin` remote."),
+	token: z.string().optional().describe("Defaults to `GITHUB_TOKEN` or `GH_TOKEN`.")
+};
+/** The release of a tag, drafts included, or `undefined`. */
+async function findRelease(client, tag) {
+	const { status, data } = await client.request("GET", `/releases/tags/${encodeURIComponent(tag)}`, { allow: [404] });
+	if (status !== 404) return data;
+	const { data: releases } = await client.request("GET", "/releases?per_page=100");
+	return releases.find((release) => release.tag_name === tag);
+}
+/**
+* Finds the release of a tag, or creates it. Other jobs may be doing the same
+* at once: when one of them wins, this waits until its release is visible and
+* uses that.
+*/
+async function ensureRelease(client, release) {
+	const existing = await findRelease(client, release.tag);
+	if (existing) return {
+		release: existing,
+		created: false
+	};
+	try {
+		const { data } = await client.request("POST", "/releases", { body: {
+			tag_name: release.tag,
+			target_commitish: release.target,
+			name: release.title,
+			body: release.notes,
+			draft: release.draft,
+			prerelease: release.prerelease
+		} });
+		return {
+			release: data,
+			created: true
+		};
+	} catch (error) {
+		if (!(error instanceof GitHubError && error.status === 422)) throw error;
+		const created = await waitFor(() => findRelease(client, release.tag), { attempts: 5 });
+		if (!created) throw error;
+		return {
+			release: created,
+			created: false
+		};
+	}
+}
+/** The name GitHub stores an asset under, e.g. `My App.zip` → `My.App.zip`. */
+function assetName(file) {
+	return file.replace(/[^\w.+@~-]/g, ".");
+}
+async function listAssets(client, release) {
+	const assets = [];
+	for (let page = 1;; page++) {
+		const { data } = await client.request("GET", `/releases/${release.id}/assets?per_page=100&page=${page}`);
+		assets.push(...data);
+		if (data.length < 100) return assets;
+	}
+}
+/**
+* Uploads a file as an asset of the release, retrying failed uploads. An
+* asset of the same name is replaced if `clobber` is set, or if it's what's
+* left of an unfinished upload.
+*/
+async function uploadAsset(client, release, asset, clobber) {
+	const name = assetName(asset.name);
+	return retry(async () => {
+		const existing = (await listAssets(client, release)).find((other) => other.name === name);
+		if (existing) {
+			if (existing.state === "uploaded" && !clobber) throw new Error(`release ${release.tag_name} already has ${name}; set clobber to replace it`);
+			await client.request("DELETE", `/releases/assets/${existing.id}`, { allow: [404] });
+		}
+		const url = new URL(release.upload_url.replace(/\{.*\}$/, ""));
+		url.searchParams.set("name", asset.name);
+		const { data } = await client.request("POST", url.href, {
+			body: asset.content,
+			contentType: "application/octet-stream",
+			attempts: 1
+		});
+		return data;
+	}, {
+		attempts: 5,
+		retryIf: isTransient
+	});
+}
+/** Whether a release is a prerelease, by the `prerelease` option. */
+function isPrerelease(option, env) {
+	return option === "auto" ? env.channel?.type === "prerelease" : option;
+}
+//#endregion
+//#region src/steps/github/release-pr.ts
+/** The branch prefix of release pull requests, and their label until released. */
+const RELEASE_BRANCH = "rylease/";
+const PENDING_LABEL = "rylease: pending";
+const MARKER = /<!-- rylease (\{[\s\S]*?\}) -->\s*$/;
+/** A pull request's body: each release's notes, then the manifest, hidden. */
+function releaseBody(manifest) {
+	return `${Object.values(manifest.components).map(({ tag, notes }) => `## ${tag}\n\n${notes.trim() || "_No notes._"}`).join("\n\n")}\n\n<!-- rylease ${JSON.stringify(manifest)} -->\n`;
+}
+/** The manifest in a pull request's body, if it has a valid one. */
+function readManifest(body) {
+	const json = MARKER.exec(body ?? "")?.[1];
+	if (json === void 0) return void 0;
+	try {
+		const manifest = JSON.parse(json);
+		return typeof manifest.components === "object" ? manifest : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/histories/github/release-pr.ts
+/**
+* Finds a release that a merged release pull request proposed: when HEAD is
+* its merge, the release steps run for the versions it proposed, with its
+* notes. Components it doesn't name, or whose tag exists already, are found
+* by their tags, as with `git/tags`.
+*/
+const githubReleasePr = defineHistory({
+	name: "github/release-pr",
+	description: "A release proposed by a release pull request from `github/open-release-pr`, once it's merged; otherwise the nearest release tag on HEAD, as `git/tags`.",
+	options: {
+		label: z.string().default(PENDING_LABEL).describe("The label of release pull requests not yet released."),
+		repo: z.string().optional().describe("`owner/repo`; defaults to `GITHUB_REPOSITORY` or the `origin` remote."),
+		token: z.string().optional().describe("Defaults to `GITHUB_TOKEN` or `GH_TOKEN`.")
+	},
+	create: (options) => {
+		const tags = gitTags();
+		let merged;
+		const find = async (cwd) => {
+			const head = await tryGit(cwd, "rev-parse", "HEAD");
+			if (head === void 0) return void 0;
+			const { data } = await githubClient(await releaseRepo(cwd, options.repo), githubToken(options.token)).request("GET", `/commits/${head}/pulls`);
+			for (const pull of data) {
+				const manifest = readManifest(pull.body);
+				if (pull.merged_at && pull.head.ref.startsWith("rylease/") && pull.labels.some((label) => label.name === options.label) && manifest) return {
+					number: pull.number,
+					manifest
+				};
+			}
+		};
+		return {
+			name: "github/release-pr",
+			find: async (input) => {
+				merged ??= find(input.env.cwd);
+				const pull = await merged;
+				const entry = pull?.manifest.components[input.component.name];
+				const released = entry === void 0 || await tryGit(input.env.cwd, "rev-parse", "--verify", "--quiet", `refs/tags/${entry.tag}`) !== void 0;
+				if (!pull || !entry || released) return tags.find(input);
+				const head = await git(input.env.cwd, "rev-parse", "HEAD");
+				return {
+					...entry.previousVersion !== void 0 && { version: entry.previousVersion },
+					reason: `#${pull.number} merged at ${head.slice(0, 7)}`,
+					pending: {
+						version: entry.version,
+						notes: entry.notes,
+						kind: entry.kind === "none" ? "fix" : entry.kind,
+						...entry.previousVersion !== void 0 && { previousVersion: entry.previousVersion },
+						reason: `proposed in #${pull.number}`
+					}
+				};
+			},
+			count: (input) => tags.count?.(input) ?? Promise.resolve(0),
+			exists: (input) => tags.exists?.(input) ?? Promise.resolve(false)
+		};
+	}
+});
+//#endregion
+//#region src/histories/index.ts
+var histories_exports = /* @__PURE__ */ __exportAll({
+	fsVersionFile: () => fsVersionFile,
+	gitTags: () => gitTags,
+	githubReleasePr: () => githubReleasePr
+});
+//#endregion
+//#region src/steps/channels.ts
+/** The `channels` option of steps that a channel's releases skip by default. */
+const channelsOption = z.boolean().default(false).describe("Also run for releases on a channel, e.g. prereleases; by default only stable releases do.");
+/**
+* For a step that leaves channel releases to the stable release, e.g. so a
+* prerelease doesn't take the changelog's entries: its output when it's
+* skipped, or `undefined` when it runs.
+*/
+function skipOnChannel(env, channels, what) {
+	if (!env.channel || channels) return void 0;
+	return {
+		output: null,
+		reason: `left ${what} for the stable release, as this is on ${env.channel.name}`
+	};
+}
+//#endregion
+//#region src/steps/change-files/parse.ts
+/**
+* Parses a change file:
+*
+* ```md
+* ---
+* "@x/core": feature
+* cli: fix
+* ---
+* Add dark mode.
+*
+* More about it.
+* ```
+*/
+function parseChangeFile(text, path) {
+	const lines = text.replace(/^/, "").split(/\r?\n/);
+	if (lines[0]?.trim() !== "---") throw new Error(`${path} must start with '---', then kinds by component`);
+	const end = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+	if (end === -1) throw new Error(`${path} has no closing '---'`);
+	const kinds = {};
+	for (const [i, line] of lines.slice(1, end).entries()) {
+		if (line.trim() === "" || line.trim().startsWith("#")) continue;
+		const match = /^\s*(?:"([^"]+)"|'([^']+)'|([^:\s]+))\s*:\s*(\S+)\s*$/.exec(line);
+		const name = match?.[1] ?? match?.[2] ?? match?.[3];
+		const kind = match?.[4];
+		if (name === void 0 || kind === void 0) throw new Error(`${path} line ${i + 2}: expected 'component: kind'`);
+		if (!KINDS.includes(kind)) throw new Error(`${path} line ${i + 2}: '${kind}' isn't a kind; use ${KINDS.join(", ")}`);
+		kinds[name] = kind;
+	}
+	const [title = "", ...rest] = lines.slice(end + 1).join("\n").trim().split("\n");
+	if (title.trim() === "") throw new Error(`${path} says nothing after its kinds`);
+	const description = rest.join("\n").trim();
+	return {
+		kinds,
+		title: title.trim(),
+		...description && { description }
+	};
+}
+//#endregion
+//#region src/steps/change-files/files.ts
+const directoryOption = z.string().default(".changes").describe("Where change files are kept, relative to the project.");
+/** Every change file in the directory, parsed, by its path in the project. */
+async function readChangeFiles(cwd, directory) {
+	const names = await readdir(join(cwd, directory)).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	});
+	const files = [];
+	for (const name of names.filter((name) => name.endsWith(".md")).sort()) {
+		if (name.toLowerCase() === "readme.md") continue;
+		const path = posix.join(directory.replaceAll("\\", "/"), name);
+		files.push({
+			path,
+			file: parseChangeFile(await readFile(join(cwd, path), "utf8"), path)
+		});
+	}
+	return files;
+}
+/**
+* The kind a change file gives a component: its own, or `kind` when the
+* component is the only one.
+*/
+function kindFor(file, component, only) {
+	return file.kinds[component] ?? (only ? file.kinds.kind : void 0);
+}
+//#endregion
+//#region src/steps/change-files/clean.ts
+/**
+* Deletes the change files a release consumed, those naming a component
+* that's released, and reports them for `git/commit` to commit their
+* deletion. Releases on a channel leave them for the stable release.
+*/
+const changeFilesClean = defineStep({
+	phase: "write",
+	name: "change-files/clean",
+	scope: "all",
+	description: "Deletes the change files of the components being released, for `git/commit` to commit; releases on a channel leave them for the stable release.",
+	options: {
+		directory: directoryOption,
+		channels: channelsOption
+	},
+	run: async ({ env, components, options }) => {
+		const skipped = skipOnChannel(env, options.channels, "the change files");
+		if (skipped) return skipped;
+		const only = components.length === 1 && components[0]?.component.path === ".";
+		const released = components.map(({ component }) => component.name);
+		const files = (await readChangeFiles(env.cwd, options.directory)).filter(({ file }) => released.some((name) => kindFor(file, name, only) !== void 0)).map(({ path }) => path);
+		if (files.length === 0) return {
+			output: { deleted: [] },
+			reason: "no change files to delete"
+		};
+		if (!env.dryRun) for (const path of files) await rm(join(env.cwd, path));
+		return {
+			output: { deleted: env.dryRun ? [] : files },
+			files,
+			reason: `${env.dryRun ? "would delete" : "deleted"} ${files.length > 3 ? plural(files.length, "change file") : joinList(files)}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/change-files/read.ts
+/**
+* Collects the change files in `.changes/`: each says what changed, and
+* how much for each component it names. A change's label is its kind, for
+* `labels/determine-kind` and `labels/determine-notes`.
+*/
+const changeFilesRead = defineStep({
+	phase: "read-changes",
+	name: "change-files/read",
+	scope: "all",
+	provides: ["changes.title", "changes.labels"],
+	description: "Collects the change files in `.changes/`, each naming the components it changes and how much, e.g. `core: feature`; each change is labeled with its kind.",
+	options: { directory: directoryOption },
+	run: async ({ env, components, options }) => {
+		const files = await readChangeFiles(env.cwd, options.directory);
+		const names = new Set(components.map(({ component }) => component.name));
+		const only = components.length === 1 && components[0]?.component.path === ".";
+		for (const { path, file } of files) for (const name of Object.keys(file.kinds)) {
+			if (names.has(name) || only && name === "kind") continue;
+			throw new Error(`${path} names '${name}', which isn't a component; use ${only ? "kind" : [...names].join(", ")}`);
+		}
+		const results = {};
+		for (const { component } of components) {
+			const changes = files.flatMap(({ path, file }) => {
+				const kind = kindFor(file, component.name, only);
+				return kind === void 0 ? [] : [{
+					title: file.title,
+					...file.description && { description: file.description },
+					labels: [kind],
+					reason: path
+				}];
+			});
+			results[component.name] = {
+				changes,
+				reason: `${plural(changes.length, "change file")} in ${options.directory}`
+			};
+		}
+		return {
+			results,
+			reason: `${plural(files.length, "change file")} in ${options.directory}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/components/dependents.ts
+const RANK$3 = {
+	none: 0,
+	fix: 1,
+	feature: 2,
+	breaking: 3
+};
+/**
+* Releases the components that depend on a released component, so their
+* releases pick up the new version, e.g. with `npm/write-version` updating
+* their dependency on it. Dependents of dependents follow.
+*/
+const componentsDependents = defineStep({
+	phase: "determine-kind",
+	name: "components/dependents",
+	scope: "all",
+	description: "Releases each component that depends on a released one, as at least a `fix`; list it after the steps that determine kinds.",
+	options: {
+		kind: z.enum([
+			"breaking",
+			"feature",
+			"fix"
+		]).default("fix").describe("The least kind of a dependent's release."),
+		on: z.array(z.enum([
+			"breaking",
+			"feature",
+			"fix"
+		])).default([
+			"breaking",
+			"feature",
+			"fix"
+		]).describe("The kinds of a dependency's release that release its dependents.")
+	},
+	run: ({ components, options }) => {
+		const kinds = new Map(components.map(({ component, kind }) => [component.name, kind ?? "none"]));
+		const results = {};
+		for (const { component } of components) {
+			const released = component.dependsOn.filter((name) => {
+				const kind = kinds.get(name) ?? "none";
+				return kind !== "none" && options.on.includes(kind);
+			});
+			const current = kinds.get(component.name) ?? "none";
+			if (released.length === 0 || RANK$3[current] >= RANK$3[options.kind]) continue;
+			kinds.set(component.name, options.kind);
+			results[component.name] = {
+				kind: options.kind,
+				reason: `depends on ${joinList(released)}, released too`
+			};
+		}
+		const raised = Object.keys(results);
+		return {
+			results,
+			reason: raised.length > 0 ? `${plural(raised.length, "dependent")} released: ${joinList(raised)}` : "no dependents of released components"
+		};
+	}
+});
+//#endregion
+//#region src/steps/conventional/classify.ts
+/** A conventional commit header, e.g. `feat(api)!: drop node 18`. */
+const HEADER = /^([a-z][\w-]*)(?:\(([^()]*)\))?(!)?: (.+)$/;
+const BREAKING = /\bBREAKING(?:[ -]CHANGES?)?\b/;
+/**
+* Splits a commit message into conventional sections. Every line that looks
+* like a conventional header starts a new section, so squashed messages with
+* several entries yield several sections. Types must start lowercase, so
+* footers like `Refs: #12` aren't mistaken for headers. Text before the first
+* header (e.g. a merge commit's subject) is ignored.
+*/
+function parseSections(message) {
+	const sections = [];
+	for (const line of message.split(/\r?\n/)) if (HEADER.test(line.trim())) sections.push({
+		title: line.trim(),
+		lines: []
+	});
+	else sections.at(-1)?.lines.push(line);
+	return sections.map(({ title, lines }) => {
+		const description = lines.join("\n").trim();
+		return description ? {
+			title,
+			description
+		} : { title };
+	});
+}
+function parseTitle(title) {
+	const match = HEADER.exec(title.trim());
+	if (!match) return void 0;
+	const [, type = "", scope, bang, subject = ""] = match;
+	return {
+		type,
+		...scope ? { scope } : {},
+		breaking: bang === "!",
+		subject
+	};
+}
+/** Whether a text mentions a breaking change (`BREAKING CHANGE:`, `BREAKING-CHANGE`, ...). */
+function mentionsBreaking(text) {
+	return text !== void 0 && BREAKING.test(text);
+}
+/** `!` or `BREAKING` → breaking; otherwise by the rules (by default `feat` → feature, the rest → fix). */
+function classify(change, rules = {
+	types: { feat: "feature" },
+	fallback: "fix"
+}) {
+	const source = `(${change.reason})`;
+	const title = change.title === void 0 ? void 0 : parseTitle(change.title);
+	const prefix = title ? `${title.type}${title.scope ? `(${title.scope})` : ""}${title.breaking ? "!" : ""}` : void 0;
+	if (title?.breaking) return {
+		kind: "breaking",
+		reason: `'${prefix}' in title ${source}`
+	};
+	if (mentionsBreaking(change.title)) return {
+		kind: "breaking",
+		reason: `'BREAKING' in title ${source}`
+	};
+	if (mentionsBreaking(change.description)) return {
+		kind: "breaking",
+		reason: `'BREAKING' in description ${source}`
+	};
+	if (!title) return {
+		kind: rules.fallback,
+		reason: `untyped change ${source}`
+	};
+	return {
+		kind: typeKey(title, rules.types) ?? rules.fallback,
+		reason: `'${prefix}' in title ${source}`
+	};
+}
+/** Looks up `type(scope)`, then `type`, in a map keyed by either. */
+function typeKey(title, map) {
+	return (title.scope ? map[`${title.type}(${title.scope})`] : void 0) ?? map[title.type];
+}
+//#endregion
+//#region src/steps/conventional/determine-kind.ts
+const RANK$2 = {
+	none: 0,
+	fix: 1,
+	feature: 2,
+	breaking: 3
+};
+/**
+* `!` or `BREAKING` → breaking; otherwise each change's kind comes from its
+* conventional type, and the highest kind wins.
+*/
+const conventionalDetermineKind = defineStep({
+	phase: "determine-kind",
+	name: "conventional/determine-kind",
+	description: "`!` or `BREAKING` → breaking; otherwise by conventional type (`feat` → feature, anything else → fix). The highest kind wins.",
+	options: {
+		types: z.record(z.string(), z.enum(KINDS)).default({}).describe("Kinds by `type` or `type(scope)`, on top of `feat: feature`, e.g. `{ docs: none, chore(deps): fix }`."),
+		fallback: z.enum(KINDS).default("fix").describe("The kind of any other change, untyped ones included.")
+	},
+	run: ({ changes, options }) => {
+		const rules = {
+			types: {
+				feat: "feature",
+				...options.types
+			},
+			fallback: options.fallback
+		};
+		let best;
+		for (const change of changes) {
+			const candidate = classify(change, rules);
+			if (!best || RANK$2[candidate.kind] > RANK$2[best.kind]) best = candidate;
+			if (best.kind === "breaking") break;
+		}
+		return best ?? {
+			kind: "none",
+			reason: "no changes"
+		};
+	}
+});
+//#endregion
+//#region src/steps/notes.ts
+/** The `dependencies` option of the steps that build notes. */
+const dependenciesOption = z.union([z.string(), z.literal(false)]).default("Dependencies").describe("The last section, for the components it depends on that were released along with it; `false` leaves it out.");
+/** A section listing released dependencies, e.g. `- core 1.2.0 → 2.0.0`. */
+function dependencySection(title, dependencies) {
+	if (title === false || dependencies.length === 0) return [];
+	return [{
+		title,
+		entries: dependencies.map(({ name, version, previousVersion }) => previousVersion === void 0 ? `- ${name} ${version}` : `- ${name} ${previousVersion} → ${version}`)
+	}];
+}
+/** Notes from the sections that have entries, and their reason. */
+function joinSections(kind, sections) {
+	const filled = sections.filter(({ entries }) => entries.length > 0);
+	return {
+		notes: filled.map(({ title, entries }) => `### ${title}\n\n${entries.join("\n")}`).join("\n\n"),
+		reason: `${kind} release; ${filled.map(({ title, entries }) => `${title.toLowerCase()}: ${entries.length}`).join(", ") || "no entries"}`
+	};
+}
+//#endregion
+//#region src/steps/conventional/determine-notes.ts
+/**
+* A `### Title` section for breaking changes, then one per group of
+* conventional types, then the rest.
+*/
+const conventionalBuildNotes = defineStep({
+	phase: "determine-notes",
+	name: "conventional/determine-notes",
+	description: "`### Breaking Changes`, `### Features`, `### Bug Fixes`, `### Performance Improvements` and `### Reverts` sections, then `### Other` for everything else.",
+	options: {
+		sections: z.array(z.strictObject({
+			title: z.string(),
+			types: z.array(z.string()).describe("`type` or `type(scope)`")
+		})).default([
+			{
+				title: "Features",
+				types: ["feat"]
+			},
+			{
+				title: "Bug Fixes",
+				types: ["fix"]
+			},
+			{
+				title: "Performance Improvements",
+				types: ["perf"]
+			},
+			{
+				title: "Reverts",
+				types: ["revert"]
+			}
+		]).describe("Sections in order; a change goes in the first that lists its type."),
+		breaking: z.union([z.string(), z.literal(false)]).default("Breaking Changes").describe("The first section, for breaking changes of any type; `false` marks them **(breaking)** in their own section instead."),
+		other: z.union([z.string(), z.literal(false)]).default("Other").describe("The section for remaining changes; `false` leaves them out."),
+		links: z.boolean().default(true).describe("Link each change to its source, e.g. its commit."),
+		dependencies: dependenciesOption
+	},
+	run: ({ changes, kind, dependencies, options }) => {
+		const section = (title, types = []) => ({
+			title,
+			types,
+			entries: []
+		});
+		const breaking = options.breaking === false ? void 0 : section(options.breaking);
+		const other = options.other === false ? void 0 : section(options.other);
+		const typed = options.sections.map(({ title, types }) => section(title, types));
+		for (const change of changes) {
+			const title = change.title ? parseTitle(change.title) : void 0;
+			const isBreaking = title?.breaking || mentionsBreaking(change.title) || mentionsBreaking(change.description);
+			const target = (isBreaking ? breaking : void 0) ?? (title && typed.find((s) => matches(title, s.types))) ?? other;
+			if (!target) continue;
+			const entry = format$1(change, title, {
+				marker: isBreaking && target !== breaking,
+				link: options.links
+			});
+			if (entry !== void 0) target.entries.push(entry);
+		}
+		return joinSections(kind, [...[
+			breaking,
+			...typed,
+			other
+		].filter((s) => s !== void 0), ...dependencySection(options.dependencies, dependencies)]);
+	}
+});
+function matches(title, types) {
+	return types.includes(title.type) || title.scope !== void 0 && types.includes(`${title.type}(${title.scope})`);
+}
+function format$1(change, parsed, style) {
+	const text = parsed ? `${parsed.scope ? `**${parsed.scope}:** ` : ""}${parsed.subject}` : (change.title ?? change.description?.split("\n")[0])?.trim();
+	if (!text) return void 0;
+	return `- ${text}${style.marker ? " **(breaking)**" : ""}${style.link && change.link ? ` ([${change.link.label}](${change.link.url}))` : ""}`;
+}
+//#endregion
+//#region src/steps/conventional/read-commits.ts
+const COMMIT_SEPARATOR = "";
+const FIELD_SEPARATOR = "";
+/**
+* Collects every conventional section (`feat: ...`, `fix(x)!: ...`) in the
+* commits since the previous release, or in all history without one. Only
+* commits touching the component count; for the whole project, when the
+* working directory is a subdirectory of the repository, only those touching
+* it. Each change links to its commit when the repository is known: on
+* GitHub, or in GitLab CI, on GitLab.
+*/
+const conventionalReadCommits = defineStep({
+	phase: "read-changes",
+	name: "conventional/read-commits",
+	description: "Collects each conventional section (`feat:`, `fix(x)!:` …) of every commit touching the component since the previous release, or in all history without one.",
+	provides: ["changes.title"],
+	run: async ({ env, component, previousRef }) => {
+		const cwd = env.cwd;
+		await assertFullHistory(cwd);
+		const log = await logSince(cwd, {
+			ref: previousRef,
+			pathspec: component.pathspec,
+			format: `%H${FIELD_SEPARATOR}%B${COMMIT_SEPARATOR}`
+		});
+		const commitUrl = await commitUrlOf(cwd);
+		const changes = [];
+		let commits = 0;
+		for (const entry of log.split(COMMIT_SEPARATOR)) {
+			const [sha, message = ""] = entry.trim().split(FIELD_SEPARATOR);
+			if (!sha) continue;
+			commits++;
+			const short = sha.slice(0, 7);
+			const link = commitUrl ? {
+				label: short,
+				url: commitUrl(sha)
+			} : void 0;
+			for (const section of parseSections(message)) changes.push({
+				...section,
+				reason: `commit ${short}`,
+				...link && { link }
+			});
+		}
+		const since = previousRef ? `since ${previousRef.slice(0, 7)}` : "in all history";
+		return {
+			changes,
+			reason: `${plural(changes.length, "change")} in ${plural(commits, "commit")} ${since}`
+		};
+	}
+});
+/** Links to commits on GitHub, or in GitLab CI on GitLab, when the repository is known. */
+async function commitUrlOf(cwd) {
+	const repo = await detectRepo(cwd);
+	if (repo) {
+		const server = process.env.GITHUB_SERVER_URL || "https://github.com";
+		return (sha) => `${server}/${repo}/commit/${sha}`;
+	}
+	const project = process.env.CI_PROJECT_URL;
+	return project ? (sha) => `${project}/-/commit/${sha}` : void 0;
+}
+//#endregion
+//#region src/utils/exec.ts
+/** Runs a command and resolves with its trimmed stdout; fails with its stderr. */
+function exec(command, args, options) {
+	return new Promise((resolve, reject) => {
+		execFile(command, args, {
+			...options,
+			maxBuffer: 67108864
+		}, (error, stdout, stderr) => {
+			if (error) {
+				const detail = stderr.trim() || error.message;
+				reject(/* @__PURE__ */ new Error(`${command} ${args.join(" ")} failed: ${detail}`));
+			} else resolve(stdout.trim());
+		});
+	});
+}
+//#endregion
+//#region src/steps/exec/run.ts
+/**
+* Runs a step's command for a component, or in a dry run its `dryRun`
+* command if it has one; resolves with what it ran, and its output.
+*/
+async function runCommand(input, options) {
+	const { env, component, placeholders } = input;
+	const command = env.dryRun && options.dryRun !== void 0 ? options.dryRun : options.command;
+	const argv = typeof command === "string" ? [
+		"sh",
+		"-c",
+		fill(command, placeholders)
+	] : command.map((part) => fill(part, placeholders));
+	const shown = typeof command === "string" ? argv[2] ?? "" : argv.join(" ");
+	if (env.dryRun && options.dryRun === void 0) return {
+		shown,
+		stdout: null
+	};
+	const [program = "", ...args] = argv;
+	return {
+		shown,
+		stdout: await exec(program, args, {
+			cwd: inComponent(env, component, options.cwd).file,
+			env: {
+				...process.env,
+				...Object.fromEntries(Object.entries(options.env).map(([key, value]) => [key, fill(value, placeholders)]))
+			}
+		})
+	};
+}
+/** The last lines of a command's output, for its reason. */
+function tail(stdout, lines = 1) {
+	return stdout.split("\n").filter((line) => line.trim()).slice(-lines).join(" ").slice(0, 200);
+}
+//#endregion
+//#region src/steps/exec/command.ts
+/**
+* Runs a command for each component in the phase it's given: in `write`,
+* e.g. `cargo update --workspace` to update a lockfile; in `release`, e.g.
+* `cargo publish` or `docker push app:{version}`.
+*/
+const execCommand = defineStep({
+	phase: (options) => options.phase,
+	name: "exec/command",
+	description: "Runs a command for each component in its `phase`: `write` e.g. to update a lockfile, listing what it changes as `files`, or `release` e.g. `cargo publish` or `docker push app:{version}`.",
+	options: {
+		phase: z.enum([
+			"write",
+			"stage",
+			"release"
+		]).describe("The phase it runs in."),
+		command: z.union([z.string(), z.array(z.string()).min(1)]).describe("`{placeholders}` are filled in. Text runs in `sh -c`; a list runs as it is, without a shell."),
+		dryRun: z.union([z.string(), z.array(z.string()).min(1)]).optional().describe("Runs instead in a dry run, e.g. `cargo publish --dry-run`; without it, a dry run only says what it would run."),
+		cwd: z.string().default(".").describe("Where it runs, relative to the component's directory."),
+		env: z.record(z.string(), z.string()).default({}).describe("More environment variables, with `{placeholders}` filled in."),
+		files: z.array(z.string()).default([]).describe("What it changes, relative to the component's directory, for `git/commit`.")
+	},
+	run: async (input) => {
+		const { env, component, options } = input;
+		const files = options.files.map((file) => inComponent(env, component, file).relative);
+		const { shown, stdout } = await runCommand(input, options);
+		if (stdout === null) return {
+			output: {
+				command: shown,
+				stdout: null
+			},
+			files,
+			reason: `would run ${shown}`
+		};
+		const last = tail(stdout);
+		return {
+			output: {
+				command: shown,
+				stdout
+			},
+			files,
+			reason: `ran ${shown}${last ? `: ${last}` : ""}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/fs/write-changes.ts
+/** Writes release notes to a file, creating it if needed. */
+const fsWriteChanges = defineStep({
+	phase: "write",
+	name: "fs/write-changes",
+	description: "Writes a heading and the notes to a file.",
+	options: {
+		path: z.string().default("CHANGELOG.md").describe("Relative to the component's directory."),
+		heading: z.string().default("## {tag} ({date})").describe(`${VERSION_PLACEHOLDERS}, and \`{date}\` (YYYY-MM-DD).`),
+		mode: z.enum([
+			"prepend",
+			"append",
+			"replace"
+		]).default("prepend"),
+		channels: channelsOption
+	},
+	run: async ({ env, component, placeholders, notes, options }) => {
+		const { heading, mode } = options;
+		const { file, relative: path } = inComponent(env, component, options.path);
+		const skipped = skipOnChannel(env, options.channels, path);
+		if (skipped) return skipped;
+		const existing = await readFile(file, "utf8").catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const entry = `${fill(heading, {
+			...placeholders,
+			date
+		})}\n\n${notes}`.trimEnd();
+		const action = existing === void 0 ? "create" : mode;
+		if (env.dryRun) return {
+			output: {
+				path,
+				entry,
+				written: false
+			},
+			files: [path],
+			reason: `would ${action} ${path}`
+		};
+		let content = [entry];
+		if (mode !== "replace") content = [
+			...mode === "prepend" ? [entry] : [],
+			...existing?.trim() ? [existing.trim()] : [],
+			...mode === "append" ? [entry] : []
+		];
+		await writeFile(file, `${content.join("\n\n")}\n`);
+		return {
+			output: {
+				path,
+				entry,
+				written: true
+			},
+			files: [path],
+			reason: `${existing === void 0 ? "created" : `${mode}${mode.endsWith("e") ? "d" : "ed"}`} ${path}`
+		};
+	}
+});
+//#endregion
+//#region src/core/scheme.ts
+/**
+* Defines a version scheme whose options are declared as a zod shape. The
+* result is a factory, like a step's: `calver({ format: "YY.MINOR.MICRO" })`.
+*/
+function defineScheme(definition) {
+	return makeFactory("scheme", definition);
+}
+//#endregion
+//#region src/schemes/semver.ts
+const PATTERN = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
+/** Whether a version is valid semver: `MAJOR.MINOR.PATCH`, without leading zeros. */
+function isSemver(version) {
+	return PATTERN.test(version.trim());
+}
+/**
+* Whether a version is a stable semantic version: one without a pre-release
+* part, which the scheme leaves to channels.
+*/
+function isStable(version) {
+	const match = PATTERN.exec(version.trim());
+	return match !== null && match[4] === void 0;
+}
+function parseSemver(version) {
+	const match = PATTERN.exec(version.trim());
+	if (!match) throw new Error(`'${version}' is not a valid semantic version`);
+	const [, major, minor, patch, prerelease, build] = match;
+	return {
+		major: Number(major),
+		minor: Number(minor),
+		patch: Number(patch),
+		...prerelease !== void 0 && { prerelease },
+		...build !== void 0 && { build }
+	};
+}
+function formatSemver(version) {
+	let text = `${version.major}.${version.minor}.${version.patch}`;
+	if (version.prerelease !== void 0) text += `-${version.prerelease}`;
+	if (version.build !== void 0) text += `+${version.build}`;
+	return text;
+}
+/** Bumps a version: `breaking` → major, `feature` → minor, `fix` → patch. */
+function bumpSemver(version, kind) {
+	const { major, minor, patch } = version;
+	switch (kind) {
+		case "breaking": return {
+			major: major + 1,
+			minor: 0,
+			patch: 0
+		};
+		case "feature": return {
+			major,
+			minor: minor + 1,
+			patch: 0
+		};
+		case "fix": return {
+			major,
+			minor,
+			patch: patch + 1
+		};
+	}
+}
+const POSITION = {
+	breaking: "major",
+	feature: "minor",
+	fix: "patch"
+};
+/**
+* `MAJOR.minor.patch`: breaking changes bump the major number, features the
+* minor and fixes the patch. Before 1.0.0, bumps shift down a level by
+* default (`0.MAJOR.minorOrPatch`).
+*/
+const semver = defineScheme({
+	name: "semver",
+	description: "`MAJOR.minor.patch` by the kind: breaking, feature or fix; `0.MAJOR.minorOrPatch` before 1.0.0.",
+	options: {
+		shiftPreMajor: z.boolean().default(true).describe("Before 1.0.0, bump breaking changes as minor and features as patch."),
+		initial: z.string().default("0.1.0").refine(isSemver, "must be a semantic version, e.g. 1.0.0").describe("The first version, when there's no previous one.")
+	},
+	create: (options) => ({
+		name: "semver",
+		traits: ["version.semver"],
+		matches: isStable,
+		compare: (a, b) => compareVersions(parseVersion(a), parseVersion(b)),
+		bump: ({ previous, kind }) => {
+			if (previous === void 0) return {
+				version: options.initial,
+				reason: `first release`
+			};
+			const parsed = parseSemver(previous);
+			const shifted = parsed.major === 0 && options.shiftPreMajor ? kind === "breaking" ? "feature" : "fix" : kind;
+			return {
+				version: formatSemver(bumpSemver(parsed, shifted)),
+				reason: shifted === kind ? `bumps ${POSITION[kind]}` : `bumps ${POSITION[shifted]} (pre-1.0)`
+			};
+		},
+		fields: (version) => {
+			const { major, minor, patch, prerelease } = parseSemver(version);
+			return {
+				major: String(major),
+				minor: String(minor),
+				patch: String(patch),
+				...prerelease !== void 0 && { prerelease }
+			};
+		}
+	})
+});
+//#endregion
+//#region src/steps/fs/write-version.ts
+/**
+* Writes each component's new version to its version file, in the project's
+* own format, keeping everything else as it was. With the `npm` and `cargo`
+* formats, dependencies on the other components released with it are
+* pointed at their new versions too, keeping each range's operator.
+*/
+const fsWriteVersion = defineStep({
+	phase: "write",
+	name: "fs/write-version",
+	scope: "all",
+	description: "Writes each component's new version to its version file: `VERSION`, `package.json`, `Cargo.toml`, `pyproject.toml`, `Chart.yaml`, `gradle.properties`, `pom.xml`, or any file by pattern. With `npm` and `cargo`, it also updates dependencies on the other components released with it, and needs `version.semver`.",
+	options: {
+		format: z.enum(FORMAT_NAMES).default("plain").describe("`plain` (the whole file), `npm`, `cargo`, `python`, `helm`, `gradle`, `maven`, or `pattern`."),
+		path: z.union([z.string(), z.array(z.string()).min(1)]).optional().describe("Relative to each component's directory; globs, or a list, write several, e.g. `packages/*/package.json` for packages sharing a version. Defaults to the format's file."),
+		pattern: z.string().optional().describe("With the `pattern` format, where the version is, e.g. `__version__ = \"{version}\"`.")
+	},
+	needs: (options) => versionFormat(options.format, options.pattern ?? "{version}").needs ?? [],
+	run: async ({ env, components, options }) => {
+		const format = versionFormat(options.format, options.pattern);
+		const patterns = [options.path ?? format.path].flat();
+		if (patterns.includes("")) throw new Error("the pattern format needs a `path`");
+		if (format.needs?.includes("version.semver")) {
+			for (const { version } of components) if (!isSemver(version)) throw new Error(`${format.name} needs a semantic version, and '${version}' isn't one`);
+		}
+		const files = (await Promise.all(components.map(async ({ component, version }) => {
+			const dir = inComponent(env, component, ".").file;
+			const found = options.format === "plain" ? patterns.map((pattern) => inComponent(env, component, pattern).file) : await resolveFiles(dir, patterns);
+			return Promise.all(found.map(async (file) => ({
+				file,
+				version,
+				text: await readFile(file, "utf8").catch((error) => {
+					if (error.code === "ENOENT") return "";
+					throw error;
+				}),
+				relative: posix.normalize(relative(env.cwd, file).replaceAll("\\", "/"))
+			})));
+		}))).flat();
+		const packages = /* @__PURE__ */ new Map();
+		for (const { text, version } of files) {
+			const name = format.packageName?.(text);
+			if (name !== void 0) packages.set(name, version);
+		}
+		const written = [];
+		for (const { file, version, text, relative: path } of files) {
+			if (text === "" && options.format !== "plain") throw new Error(`${path} doesn't exist`);
+			let result;
+			try {
+				result = format.write(text, version, packages);
+			} catch (error) {
+				throw new Error(`can't write ${version} to ${path}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (!env.dryRun) await writeFile(file, result.text);
+			written.push({
+				path,
+				version,
+				dependencies: result.dependencies
+			});
+		}
+		const described = joinList(written.map(({ path, version, dependencies }) => `${version} to ${path}${dependencies.length > 0 ? ` (and ${joinList(dependencies)})` : ""}`));
+		return {
+			output: { written: env.dryRun ? [] : written },
+			files: written.map(({ path }) => path),
+			reason: `${env.dryRun ? "would write" : "wrote"} ${described}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/git/placeholders.ts
+/**
+* Placeholders for what's released as a whole: `{tags}`, every release's
+* tag, and with one component, its own placeholders.
+*/
+function releasedPlaceholders(components) {
+	const [only] = components;
+	return {
+		...components.length === 1 && only ? only.placeholders : {},
+		tags: components.map(({ tag }) => tag).join(", ")
+	};
+}
+//#endregion
+//#region src/steps/git/commit.ts
+/**
+* Commits the files that earlier `release` steps changed, for every
+* component, in one commit. Without this the version bump never lands.
+* Pushing is off by default, so `git/create-tag` can push the commit and its
+* tags together.
+*/
+const gitCommit = defineStep({
+	phase: "stage",
+	name: "git/commit",
+	scope: "all",
+	description: "Commits the files earlier release steps changed, for every component, in one commit.",
+	options: {
+		files: z.array(z.string()).default([]).describe("More files to commit, relative to the working directory."),
+		message: z.string().default("chore(release): {tags}").describe("The commit message; `{tags}` is filled in with every release's tag, and with one component, its placeholders too, e.g. `{version}`."),
+		push: z.union([z.string(), z.literal(false)]).default(false).describe("The remote to push the branch to; `false` leaves it to a later step, e.g. `git/create-tag`, so the commit and tag land together.")
+	},
+	run: async ({ env, components, options }) => {
+		const remote = options.push;
+		const message = fill(options.message, releasedPlaceholders(components));
+		const files = [.../* @__PURE__ */ new Set([...components.flatMap(({ releases }) => releases.flatMap((release) => release.files)), ...options.files])];
+		if (files.length === 0) throw new Error("no files to commit; no earlier step reported any");
+		const pushing = remote ? ` and push to ${remote}` : "";
+		if (env.dryRun) return {
+			output: {
+				commit: null,
+				pushed: false
+			},
+			reason: `would commit ${files.join(", ")}${pushing}`
+		};
+		const cwd = env.cwd;
+		await git(cwd, "add", "--all", "--", ...files);
+		if (await git(cwd, "diff", "--cached", "--name-only") === "") throw new Error("nothing to commit");
+		await git(cwd, ...await identity(cwd), "commit", "-m", message);
+		const commit = await git(cwd, "rev-parse", "HEAD");
+		if (remote) await git(cwd, "push", remote, "HEAD");
+		return {
+			output: {
+				commit,
+				pushed: remote !== false
+			},
+			reason: `committed ${commit.slice(0, 7)}${remote ? ` and pushed to ${remote}` : ""}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/git/create-tag.ts
+/**
+* Tags HEAD with every component's release, moves any floating tags to it,
+* and pushes them along with the current branch in one atomic push, so a
+* commit from `git/commit` and its tags land together or not at all.
+*/
+const gitCreateTag = defineStep({
+	phase: "release",
+	name: "git/create-tag",
+	scope: "all",
+	description: "Tags HEAD with each release's tag and pushes them, along with the branch, in one atomic push.",
+	options: {
+		message: z.string().default("chore(release): {tag}").describe(`The tag message; ${VERSION_PLACEHOLDERS}.`),
+		move: z.array(z.string()).default([]).describe("Tags to create or move to each release, e.g. `v{major}`; force-pushed. Those with `{channel}` only move on a channel, e.g. to `next`, and the others only on stable releases."),
+		push: z.union([z.string(), z.literal(false)]).default(false).describe("The remote to push the tags and the current branch to; `false` skips pushing.")
+	},
+	run: async ({ env, components, options }) => {
+		const remote = options.push;
+		const tags = components.map(({ tag, placeholders }) => ({
+			tag,
+			message: fill(options.message, placeholders)
+		}));
+		const moved = [...new Set(components.flatMap(({ placeholders }) => options.move.filter((name) => name.includes("{channel}") === (env.channel !== void 0)).map((name) => fill(name, placeholders))))];
+		const names = joinList(tags.map(({ tag }) => tag));
+		if (env.dryRun) return {
+			output: {
+				tags: tags.map(({ tag }) => tag),
+				moved,
+				pushed: false
+			},
+			reason: `would ${joinList([
+				`tag ${names}`,
+				...moved.length ? [`move ${moved.join(", ")}`] : [],
+				...remote ? [`push to ${remote}`] : []
+			])}`
+		};
+		const cwd = env.cwd;
+		const head = await git(cwd, "rev-parse", "HEAD");
+		const who = await identity(cwd);
+		for (const { tag, message } of tags) await git(cwd, ...who, "tag", "-a", tag, "-m", message);
+		for (const name of moved) await git(cwd, "tag", "-f", name, "HEAD");
+		if (remote) await git(cwd, "push", "--atomic", remote, ...await tryGit(cwd, "symbolic-ref", "-q", "HEAD") ? ["HEAD"] : [], ...tags.map(({ tag }) => `refs/tags/${tag}`), ...moved.map((name) => `+refs/tags/${name}`));
+		return {
+			output: {
+				tags: tags.map(({ tag }) => tag),
+				moved,
+				pushed: remote !== false
+			},
+			reason: joinList([
+				`tagged ${names} at ${head.slice(0, 7)}`,
+				...moved.length ? [`moved ${moved.join(", ")}`] : [],
+				...remote ? [`pushed to ${remote}`] : []
+			])
+		};
+	}
+});
+//#endregion
+//#region src/steps/github/create-release.ts
+/**
+* Creates a GitHub release for the version, with the notes as its body, or
+* finds the one another job already created.
+*/
+const githubCreateRelease = defineStep({
+	phase: "release",
+	name: "github/create-release",
+	description: "Creates a GitHub release of the tag with the notes, unless it already has one; the tag is created at HEAD if it doesn't exist. Needs a token with `contents: write`.",
+	options: releaseOptions,
+	run: async ({ env, tag, placeholders, notes, options }) => {
+		const title = fill(options.title, placeholders);
+		const repo = await releaseRepo(env.cwd, options.repo);
+		if (env.dryRun) return {
+			output: {
+				repo,
+				tag,
+				url: null
+			},
+			reason: `would create release ${tag} on ${repo}`
+		};
+		const { release, created } = await ensureRelease(githubClient(repo, githubToken(options.token)), {
+			tag,
+			target: await git(env.cwd, "rev-parse", "HEAD"),
+			title,
+			notes,
+			draft: options.draft,
+			prerelease: isPrerelease(options.prerelease, env)
+		});
+		return {
+			output: {
+				repo,
+				tag,
+				id: release.id,
+				url: release.html_url
+			},
+			reason: `${created ? "created" : "found existing"} release ${tag}: ${release.html_url}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/github/open-release-pr.ts
+/**
+* Proposes the release as a pull request instead of releasing it: commits
+* what earlier `write` steps changed to a release branch, and opens a pull
+* request for it, or updates the one that's open. The release steps wait
+* until it merges; then the `github/release-pr` history finds it, and they
+* run for what it proposed.
+*/
+const githubOpenReleasePr = defineStep({
+	phase: "stage",
+	name: "github/open-release-pr",
+	scope: "all",
+	description: "Commits the prepared release to a branch and opens a pull request for it, or updates the open one; the release waits until it merges. Use with the `github/release-pr` history. List it after the `write` steps, in place of `git/commit`.",
+	options: {
+		branch: z.string().default(`${RELEASE_BRANCH}{branch}`).describe("The release branch, force-pushed; `{branch}` is the branch being released."),
+		title: z.string().default("chore(release): {tags}").describe("The commit message and title; `{tags}` lists every release's tag."),
+		labels: z.array(z.string()).default([PENDING_LABEL]).describe("Labels for the pull request; `github/release-pr` looks for the first."),
+		remote: z.string().default("origin").describe("Where to push the branch."),
+		repo: z.string().optional().describe("`owner/repo`; defaults to `GITHUB_REPOSITORY` or the `origin` remote."),
+		token: z.string().optional().describe("Defaults to `GITHUB_TOKEN` or `GH_TOKEN`; needs `pull-requests: write`.")
+	},
+	run: async ({ env, components, options }) => {
+		const tags = components.map(({ tag }) => tag).join(", ");
+		const branch = fill(options.branch, { branch: env.branch });
+		const title = fill(options.title, { tags });
+		const files = [...new Set(components.flatMap(({ releases }) => releases.flatMap((release) => release.files)))];
+		const manifest = { components: Object.fromEntries(components.map((component) => [component.component.name, {
+			version: component.version,
+			tag: component.tag,
+			kind: component.kind,
+			...component.previousVersion !== void 0 && { previousVersion: component.previousVersion },
+			notes: component.notes
+		}])) };
+		const repo = await releaseRepo(env.cwd, options.repo);
+		if (env.dryRun) return {
+			output: {
+				branch,
+				number: null,
+				url: null
+			},
+			files,
+			reason: `would push ${files.length > 0 ? joinList(files) : "nothing new"} to ${branch} and propose ${tags} on ${repo}`,
+			defer: `released when the pull request for ${tags} merges`
+		};
+		const client = githubClient(repo, githubToken(options.token));
+		const cwd = env.cwd;
+		const back = await tryGit(cwd, "symbolic-ref", "-q", "--short", "HEAD") ?? await git(cwd, "rev-parse", "HEAD");
+		await git(cwd, "checkout", "-q", "--detach");
+		try {
+			if (files.length > 0) await git(cwd, "add", "--all", "--", ...files);
+			await git(cwd, ...await identity(cwd), "commit", "-q", "--allow-empty", "-m", title);
+			await git(cwd, "push", "--force", options.remote, `HEAD:refs/heads/${branch}`);
+		} finally {
+			await git(cwd, "checkout", "-q", "--force", back);
+		}
+		const owner = repo.split("/")[0];
+		const { data: open } = await client.request("GET", `/pulls?state=open&head=${encodeURIComponent(`${owner}:${branch}`)}`);
+		const body = releaseBody(manifest);
+		let pull;
+		const [existing] = open;
+		if (existing) pull = (await client.request("PATCH", `/pulls/${existing.number}`, { body: {
+			title,
+			body
+		} })).data;
+		else pull = (await client.request("POST", "/pulls", { body: {
+			title,
+			body,
+			head: branch,
+			base: env.branch
+		} })).data;
+		if (options.labels.length > 0) await client.request("POST", `/issues/${pull.number}/labels`, { body: { labels: options.labels } });
+		return {
+			output: {
+				branch,
+				number: pull.number,
+				url: pull.html_url
+			},
+			files,
+			reason: `${existing ? "updated" : "opened"} #${pull.number} for ${tags}, with ${plural(files.length, "file")}: ${pull.html_url}`,
+			defer: `released when #${pull.number} merges`
+		};
+	}
+});
+//#endregion
+//#region src/steps/github/read-pull-requests.ts
+/** Commits looked up at once. */
+const CONCURRENCY = 8;
+/**
+* Collects the pull requests merged into the branch through the commits
+* touching the component since the previous release, or in all history
+* without one, each with its labels. Commits that weren't merged through a
+* pull request aren't counted.
+*/
+const githubReadPullRequests = defineStep({
+	phase: "read-changes",
+	name: "github/read-pull-requests",
+	description: "Collects the pull requests merged into the branch by the commits touching the component since the previous release, with their labels. Needs a token that can read pull requests.",
+	provides: [
+		"changes.title",
+		"changes.labels",
+		"changes.link"
+	],
+	options: {
+		repo: z.string().optional().describe("`owner/repo`; defaults to `GITHUB_REPOSITORY` or the `origin` remote."),
+		token: z.string().optional().describe("Defaults to `GITHUB_TOKEN` or `GH_TOKEN`.")
+	},
+	run: async ({ env, component, previousRef, options }) => {
+		const cwd = env.cwd;
+		await assertFullHistory(cwd);
+		const shas = (await logSince(cwd, {
+			ref: previousRef,
+			pathspec: component.pathspec,
+			format: "%H"
+		})).split("\n").filter(Boolean);
+		const client = githubClient(await releaseRepo(cwd, options.repo), githubToken(options.token));
+		const found = /* @__PURE__ */ new Map();
+		for (let i = 0; i < shas.length; i += CONCURRENCY) {
+			const batch = await Promise.all(shas.slice(i, i + CONCURRENCY).map(async (sha) => {
+				const { data } = await client.request("GET", `/commits/${sha}/pulls`);
+				return data;
+			}));
+			for (const pull of batch.flat()) if (pull.merged_at && pull.base.ref === env.branch) found.set(pull.number, pull);
+		}
+		const changes = [...found.values()].map((pull) => ({
+			title: pull.title,
+			...pull.body?.trim() && { description: pull.body.trim() },
+			reason: `PR #${pull.number}`,
+			link: {
+				label: `#${pull.number}`,
+				url: pull.html_url
+			},
+			labels: pull.labels.map((label) => label.name)
+		}));
+		const since = previousRef ? `since ${previousRef.slice(0, 7)}` : "in all history";
+		return {
+			changes,
+			reason: `${plural(changes.length, "pull request")} in ${plural(shas.length, "commit")} ${since}`
+		};
+	}
+});
+//#endregion
+//#region src/utils/zip.ts
+const deflate = promisify(deflateRaw);
+const LIMIT = 4294967295;
+/**
+* Zips files, deflated, into one buffer. Without ZIP64, the archive and each
+* file must stay under 4 GiB.
+*/
+async function zip(entries) {
+	const parts = [];
+	const central = [];
+	let offset = 0;
+	for (const entry of entries) {
+		const name = Buffer.from(entry.name.replaceAll("\\", "/"));
+		const data = await deflate(entry.content);
+		if (entry.content.length >= LIMIT || offset + data.length >= LIMIT) throw new Error(`'${entry.name}' is too large to zip (4 GiB at most)`);
+		const crc = crc32(entry.content);
+		const fields = (header, at) => {
+			header.writeUInt16LE(20, at);
+			header.writeUInt16LE(2048, at + 2);
+			header.writeUInt16LE(8, at + 4);
+			header.writeUInt16LE(0, at + 6);
+			header.writeUInt16LE(33, at + 8);
+			header.writeUInt32LE(crc, at + 10);
+			header.writeUInt32LE(data.length, at + 14);
+			header.writeUInt32LE(entry.content.length, at + 18);
+			header.writeUInt16LE(name.length, at + 22);
+			header.writeUInt16LE(0, at + 24);
+		};
+		const local = Buffer.alloc(30);
+		local.writeUInt32LE(67324752, 0);
+		fields(local, 4);
+		const record = Buffer.alloc(46);
+		record.writeUInt32LE(33639248, 0);
+		record.writeUInt16LE(20, 4);
+		fields(record, 6);
+		record.writeUInt32LE(offset, 42);
+		central.push(record, name);
+		parts.push(local, name, data);
+		offset += local.length + name.length + data.length;
+	}
+	const directory = Buffer.concat(central);
+	const end = Buffer.alloc(22);
+	end.writeUInt32LE(101010256, 0);
+	end.writeUInt16LE(entries.length, 8);
+	end.writeUInt16LE(entries.length, 10);
+	end.writeUInt32LE(directory.length, 12);
+	end.writeUInt32LE(offset, 16);
+	return Buffer.concat([
+		...parts,
+		directory,
+		end
+	]);
+}
+//#endregion
+//#region src/steps/github/artifact.ts
+const SERVICE = "twirp/github.actions.results.api.v1.ArtifactService";
+/** Whether this is a job that can upload workflow artifacts. */
+function canUploadArtifacts() {
+	return Boolean(process.env.ACTIONS_RESULTS_URL && process.env.ACTIONS_RUNTIME_TOKEN);
+}
+/** The job's artifact service, from what the runner gives JavaScript actions. */
+function service() {
+	const url = process.env.ACTIONS_RESULTS_URL;
+	const token = process.env.ACTIONS_RUNTIME_TOKEN;
+	if (!url || !token) throw new Error("no artifact service; workflow artifacts can only be uploaded by the rylease action in a GitHub Actions job");
+	const [, run, job] = (JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64url").toString()).scp?.split(" ").find((scope) => scope.startsWith("Actions.Results:")))?.split(":") ?? [];
+	if (!run || !job) throw new Error("the runtime token names no job");
+	return {
+		ids: {
+			workflow_run_backend_id: run,
+			workflow_job_run_backend_id: job
+		},
+		call: async (method, body) => {
+			const response = await fetch(`${new URL(url).origin}/${SERVICE}/${method}`, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${token}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+			const text = await response.text();
+			if (!response.ok) throw new Error(`artifact service responded ${response.status} to ${method}: ${text}`);
+			return JSON.parse(text);
+		}
+	};
+}
+/** Uploads a zip as a workflow artifact; resolves with its id. */
+async function uploadArtifact(name, content, retentionDays) {
+	const { ids, call } = service();
+	const created = await call("CreateArtifact", {
+		...ids,
+		name,
+		version: 4,
+		...retentionDays !== void 0 && { expires_at: new Date(Date.now() + retentionDays * 864e5).toISOString() }
+	});
+	if (!created.ok) throw new Error(`couldn't create artifact '${name}'`);
+	await retry(async () => {
+		const response = await fetch(created.signed_upload_url, {
+			method: "PUT",
+			headers: {
+				"x-ms-blob-type": "BlockBlob",
+				"x-ms-version": "2020-10-02",
+				"content-type": "application/zip"
+			},
+			body: content
+		});
+		if (!response.ok) throw new Error(`artifact storage responded ${response.status}: ${await response.text()}`);
+	}, { attempts: 5 });
+	const finalized = await call("FinalizeArtifact", {
+		...ids,
+		name,
+		size: String(content.length),
+		hash: `sha256:${createHash("sha256").update(content).digest("hex")}`
+	});
+	if (!finalized.ok) throw new Error(`couldn't finalize artifact '${name}'`);
+	return finalized.artifact_id;
+}
+/**
+* Zips files as a workflow artifact, with paths relative to their closest
+* common directory, as `actions/upload-artifact` does.
+*/
+async function uploadFiles(name, files, retentionDays) {
+	const root = files.map(dirname).reduce(commonDirectory);
+	const entries = await Promise.all(files.map(async (file) => ({
+		name: relative(root, file).split(sep).join("/"),
+		content: await readFile(file)
+	})));
+	const sizes = await Promise.all(files.map(async (file) => (await stat(file)).size));
+	return {
+		id: await uploadArtifact(name, await zip(entries), retentionDays),
+		files: entries.map((entry) => entry.name),
+		size: sizes.reduce((sum, bytes) => sum + bytes, 0)
+	};
+}
+function commonDirectory(a, b) {
+	const left = a.split(sep);
+	const right = b.split(sep);
+	let length = 0;
+	while (length < left.length && left[length] === right[length]) length++;
+	return left.slice(0, length).join(sep) || sep;
+}
+//#endregion
+//#region src/steps/github/upload-artifact.ts
+/**
+* Keeps files as an artifact of the workflow run; with `dryRunArtifact`, in
+* dry runs too, e.g. to keep what a dry run built.
+*/
+const githubUploadArtifact = defineStep({
+	phase: "release",
+	name: "github/upload-artifact",
+	description: "Uploads files as a workflow artifact. Only works in the GitHub Action.",
+	options: {
+		name: z.string().describe("The artifact's name, unique in the run; `{version}`, `{tag}` and the other placeholders are filled in."),
+		files: z.array(z.string()).min(1).describe("Paths, globs or directories, relative to the component's directory unless absolute; each must match."),
+		dryRunArtifact: z.boolean().default(false).describe("Upload in dry runs too."),
+		retentionDays: z.number().int().min(1).optional().describe("Defaults to the repository's setting.")
+	},
+	run: async ({ env, component, placeholders, options }) => {
+		const name = fill(options.name, placeholders);
+		const files = await resolveFiles(inComponent(env, component, ".").file, options.files);
+		const listed = `${plural(files.length, "file")} as artifact ${name}`;
+		if (env.dryRun && !(options.dryRunArtifact && canUploadArtifacts())) return {
+			output: {
+				name,
+				id: null,
+				files: []
+			},
+			reason: `would upload ${listed}${options.dryRunArtifact ? " (outside GitHub Actions)" : ""}`
+		};
+		const uploaded = await uploadFiles(name, files, options.retentionDays);
+		return {
+			output: {
+				name,
+				id: uploaded.id,
+				files: uploaded.files
+			},
+			reason: `uploaded ${plural(files.length, "file")} (${formatSize(uploaded.size)}) as artifact ${name}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/github/upload-release-assets.ts
+/**
+* Uploads files to the version's GitHub release, creating the release if no
+* other step or job has yet, so that jobs building different files can each
+* upload their own.
+*/
+const githubUploadReleaseAssets = defineStep({
+	phase: "release",
+	name: "github/upload-release-assets",
+	description: "Uploads files to the GitHub release, creating it (with the notes) if no other job has yet.",
+	options: {
+		files: z.array(z.string()).min(1).describe("Paths or globs, relative to the component's directory unless absolute; each must match."),
+		clobber: z.boolean().default(true).describe("Replace assets of the same name."),
+		dryRunArtifact: z.boolean().default(false).describe("In dry runs, keep the files as a workflow artifact instead; only in the GitHub Action."),
+		artifactName: z.string().optional().describe("Unique in the run; `{version}`, `{tag}` and the other placeholders are filled in. Defaults to the asset's name, or for several, a name made from theirs."),
+		...releaseOptions
+	},
+	run: async ({ env, component, tag, placeholders, notes, options }) => {
+		const title = fill(options.title, placeholders);
+		const repo = await releaseRepo(env.cwd, options.repo);
+		const files = await resolveFiles(inComponent(env, component, ".").file, options.files);
+		const sizes = await Promise.all(files.map(async (file) => (await stat(file)).size));
+		const listed = files.map((file, index) => `${assetName(basename(file))} (${formatSize(sizes[index] ?? 0)})`);
+		if (env.dryRun) {
+			const reason = `would upload ${joinList(listed)} to release ${tag} on ${repo}`;
+			if (!options.dryRunArtifact) return {
+				output: {
+					repo,
+					tag,
+					url: null,
+					assets: []
+				},
+				reason
+			};
+			const artifact = artifactNameOf(files, options.artifactName, placeholders);
+			if (!canUploadArtifacts()) return {
+				output: {
+					repo,
+					tag,
+					url: null,
+					assets: [],
+					artifact: null
+				},
+				reason: `${reason} (no artifact ${artifact} outside GitHub Actions)`
+			};
+			const { id } = await uploadFiles(artifact, files);
+			return {
+				output: {
+					repo,
+					tag,
+					url: null,
+					assets: [],
+					artifact: {
+						name: artifact,
+						id
+					}
+				},
+				reason: `${reason}; kept them as artifact ${artifact}`
+			};
+		}
+		const client = githubClient(repo, githubToken(options.token));
+		const { release, created } = await ensureRelease(client, {
+			tag,
+			target: await git(env.cwd, "rev-parse", "HEAD"),
+			title,
+			notes,
+			draft: options.draft,
+			prerelease: isPrerelease(options.prerelease, env)
+		});
+		const assets = [];
+		for (const file of files) {
+			const asset = await uploadAsset(client, release, {
+				name: basename(file),
+				content: await readFile(file)
+			}, options.clobber);
+			assets.push({
+				name: asset.name,
+				size: asset.size,
+				url: asset.browser_download_url
+			});
+		}
+		return {
+			output: {
+				repo,
+				tag,
+				url: release.html_url,
+				assets
+			},
+			reason: `uploaded ${joinList(listed)} to ${created ? "new" : "existing"} release ${tag}: ${release.html_url}`
+		};
+	}
+});
+function artifactNameOf(files, name, placeholders) {
+	if (name !== void 0) return fill(name, placeholders);
+	const assets = files.map((file) => assetName(basename(file)));
+	if (assets.length === 1 && assets[0]) return assets[0];
+	return `release-assets-${createHash("sha256").update(assets.join("\n")).digest("hex").slice(0, 8)}`;
+}
+//#endregion
+//#region src/steps/gitlab/create-release.ts
+var GitLabError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "GitLabError";
+		this.status = status;
+	}
+};
+/**
+* Creates a GitLab release for the version, with the notes as its
+* description, or finds the one another job already created. In GitLab CI,
+* the project, API and job token come from the job's environment.
+*/
+const gitlabCreateRelease = defineStep({
+	phase: "release",
+	name: "gitlab/create-release",
+	description: "Creates a GitLab release of the tag with the notes, unless it already has one; the tag is created at HEAD if it doesn't exist.",
+	options: {
+		title: z.string().default("{tag}").describe("`{tag}`, `{version}`, `{name}` and the scheme's placeholders are filled in."),
+		project: z.string().optional().describe("The project's ID or path, e.g. `group/project`; defaults to `CI_PROJECT_ID`."),
+		token: z.string().optional().describe("Defaults to `GITLAB_TOKEN`, then the job's `CI_JOB_TOKEN`.")
+	},
+	run: async ({ env, tag, placeholders, notes, options }) => {
+		const title = fill(options.title, placeholders);
+		const project = options.project ?? process.env.CI_PROJECT_ID;
+		if (!project) throw new Error("couldn't determine the GitLab project; set `project` or CI_PROJECT_ID");
+		if (env.dryRun) return {
+			output: {
+				project,
+				tag,
+				url: null
+			},
+			reason: `would create release ${tag} on ${project}`
+		};
+		const request = gitlabClient(project, options.token);
+		let created = true;
+		let release;
+		try {
+			release = await request("POST", "/releases", {
+				tag_name: tag,
+				ref: await git(env.cwd, "rev-parse", "HEAD"),
+				name: title,
+				description: notes
+			});
+		} catch (error) {
+			if (!(error instanceof GitLabError && error.status === 409)) throw error;
+			created = false;
+			release = await request("GET", `/releases/${encodeURIComponent(tag)}`);
+		}
+		const url = release._links.self;
+		return {
+			output: {
+				project,
+				tag,
+				url
+			},
+			reason: `${created ? "created" : "found existing"} release ${tag}: ${url}`
+		};
+	}
+});
+/** Requests to a project's REST API, retrying rate limits and server errors. */
+function gitlabClient(project, token) {
+	const api = process.env.CI_API_V4_URL || "https://gitlab.com/api/v4";
+	const auth = token ?? process.env.GITLAB_TOKEN;
+	const header = auth ? { "private-token": auth } : process.env.CI_JOB_TOKEN ? { "job-token": process.env.CI_JOB_TOKEN } : void 0;
+	if (!header) throw new Error("no token; set GITLAB_TOKEN, or run in GitLab CI");
+	return (method, path, body) => retry(async () => {
+		const url = `${api}/projects/${encodeURIComponent(project)}${path}`;
+		const response = await fetch(url, {
+			method,
+			headers: {
+				...header,
+				...body !== void 0 && { "content-type": "application/json" }
+			},
+			...body !== void 0 && { body: JSON.stringify(body) }
+		});
+		const text = await response.text();
+		if (!response.ok) throw new GitLabError(response.status, `GitLab responded ${response.status} to ${method} ${url}: ${text}`);
+		return JSON.parse(text);
+	}, {
+		attempts: 5,
+		retryIf: (error) => error instanceof GitLabError ? error.status === 429 || error.status >= 500 : error instanceof TypeError
+	});
+}
+//#endregion
+//#region src/steps/keep-a-changelog/changelog.ts
+/** The `## [Unreleased]` heading of a Keep a Changelog file. */
+const UNRELEASED = /^##\s+\[?unreleased\]?\s*$/i;
+/** Finds the `## [Unreleased]` section of a changelog's lines. */
+function findUnreleased(lines, path) {
+	const start = lines.findIndex((line) => UNRELEASED.test(line));
+	if (start === -1) throw new Error(`${path} has no '## [Unreleased]' section`);
+	const next = lines.findIndex((line, i) => i > start && /^##\s/.test(line));
+	return {
+		start,
+		end: next === -1 ? lines.length : next
+	};
+}
+//#endregion
+//#region src/steps/keep-a-changelog/read-unreleased.ts
+/**
+* Collects the entries of the `## [Unreleased]` section of a changelog kept as
+* on keepachangelog.com: each top-level bullet is a change, labeled with its
+* `### Added`, `### Fixed` … heading, and the lines under it its description.
+*/
+const keepAChangelogReadUnreleased = defineStep({
+	phase: "read-changes",
+	name: "keep-a-changelog/read-unreleased",
+	description: "Collects each entry under `## [Unreleased]` in a Keep a Changelog file, labeled with its `### Added`, `### Fixed` … heading.",
+	provides: ["changes.title", "changes.labels"],
+	options: { path: z.string().default("CHANGELOG.md").describe("Relative to the component's directory.") },
+	run: async ({ env, component, options }) => {
+		const { file, relative: path } = inComponent(env, component, options.path);
+		const lines = (await readFile(file, "utf8")).split(/\r?\n/);
+		const { start, end } = findUnreleased(lines, path);
+		const changes = [];
+		let category;
+		let current;
+		const finish = () => {
+			const description = current?.body.join("\n").trim();
+			if (current && description) current.change.description = description;
+			current = void 0;
+		};
+		for (let i = start + 1; i < end; i++) {
+			const line = lines[i] ?? "";
+			const heading = /^###\s+(.+?)\s*$/.exec(line);
+			const bullet = /^[-*+]\s+(.*)$/.exec(line);
+			if (heading) {
+				finish();
+				category = heading[1];
+			} else if (bullet) {
+				finish();
+				current = {
+					change: {
+						title: (bullet[1] ?? "").trim(),
+						reason: `${path} line ${i + 1}`,
+						labels: category ? [category] : []
+					},
+					body: []
+				};
+				changes.push(current.change);
+			} else if (current && (line.trim() === "" || /^\s/.test(line))) current.body.push(line.replace(/^ {1,2}|^\t/, ""));
+			else finish();
+		}
+		finish();
+		return {
+			changes,
+			reason: `${plural(changes.length, "entry", "entries")} under ${lines[start]?.trim()} in ${path}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/keep-a-changelog/write-release.ts
+/** A `[unreleased]: <base>/compare/<tag>...HEAD` link definition. */
+const UNRELEASED_LINK = /^\[unreleased\]:\s*(\S+)\/compare\/(\S+?)\.\.\.HEAD\s*$/i;
+/**
+* Releases the `## [Unreleased]` section of a Keep a Changelog file: its
+* entries move under a heading for the version, and an empty
+* `## [Unreleased]` takes its place. A `[unreleased]: …/compare/v1.0.0...HEAD`
+* link moves on to the new tag, and the version gets its own compare link.
+*/
+const keepAChangelogWriteRelease = defineStep({
+	phase: "write",
+	name: "keep-a-changelog/write-release",
+	description: "Moves the entries under `## [Unreleased]` to a heading for the version, and updates the compare links, if there are any.",
+	options: {
+		path: z.string().default("CHANGELOG.md").describe("Relative to the component's directory."),
+		heading: z.string().default("## [{version}] - {date}").describe(`${VERSION_PLACEHOLDERS}, and \`{date}\` (YYYY-MM-DD).`),
+		channels: channelsOption
+	},
+	run: async ({ env, component, version, tag, placeholders, options }) => {
+		const { file, relative: path } = inComponent(env, component, options.path);
+		const skipped = skipOnChannel(env, options.channels, path);
+		if (skipped) return skipped;
+		const text = await readFile(file, "utf8");
+		const lines = text.split(/\r?\n/);
+		const { start } = findUnreleased(lines, path);
+		const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const heading = fill(options.heading, {
+			...placeholders,
+			date
+		});
+		lines.splice(start + 1, 0, "", heading);
+		const link = lines.findIndex((line) => UNRELEASED_LINK.test(line));
+		const [, base, previous] = UNRELEASED_LINK.exec(lines[link] ?? "") ?? [];
+		if (base !== void 0 && previous !== void 0) lines.splice(link, 1, `[unreleased]: ${base}/compare/${tag}...HEAD`, `[${version}]: ${base}/compare/${previous}...${tag}`);
+		const updated = `${heading}${base ? " and its compare link" : ""}`;
+		if (env.dryRun) return {
+			output: {
+				path,
+				heading,
+				written: false
+			},
+			files: [path],
+			reason: `would add ${updated} to ${path}`
+		};
+		await writeFile(file, lines.join(text.includes("\r\n") ? "\r\n" : "\n"));
+		return {
+			output: {
+				path,
+				heading,
+				written: true
+			},
+			files: [path],
+			reason: `added ${updated} to ${path}`
+		};
+	}
+});
+//#endregion
+//#region src/steps/labels/labels.ts
+/** Labels compare case-insensitively, as GitHub's do. */
+function hasLabel(change, labels) {
+	const wanted = labels.map((label) => label.toLowerCase());
+	return (change.labels ?? []).some((label) => wanted.includes(label.toLowerCase()));
+}
+/** Looks a label up in a map keyed by labels, ignoring case. */
+function lookup(map, label) {
+	const key = Object.keys(map).find((other) => other.toLowerCase() === label.toLowerCase());
+	return key === void 0 ? void 0 : map[key];
+}
+//#endregion
+//#region src/steps/labels/determine-kind.ts
+const RANK$1 = {
+	none: 0,
+	fix: 1,
+	feature: 2,
+	breaking: 3
+};
+/**
+* Each change's kind comes from its labels, e.g. a pull request's: the
+* highest of them, or `fallback` when none is mapped. The highest kind wins.
+*/
+const labelsDetermineKind = defineStep({
+	phase: "determine-kind",
+	name: "labels/determine-kind",
+	description: "By each change's labels, e.g. a pull request's (`breaking` → breaking, `enhancement` → feature, anything else → fix). The highest kind wins.",
+	needs: ["changes.labels"],
+	options: {
+		kinds: z.record(z.string(), z.enum(KINDS)).default({
+			breaking: "breaking",
+			"semver:major": "breaking",
+			feature: "feature",
+			enhancement: "feature",
+			"semver:minor": "feature"
+		}).describe("Kinds by label, ignoring case."),
+		fallback: z.enum(KINDS).default("fix").describe("The kind of a change without a label in `kinds`.")
+	},
+	run: ({ changes, options }) => {
+		let best;
+		for (const change of changes) {
+			let candidate = {
+				kind: options.fallback,
+				reason: `no label in kinds (${change.reason})`
+			};
+			for (const label of change.labels ?? []) {
+				const kind = lookup(options.kinds, label);
+				if (kind !== void 0 && RANK$1[kind] > RANK$1[candidate.kind]) candidate = {
+					kind,
+					reason: `'${label}' label (${change.reason})`
+				};
+			}
+			if (!best || RANK$1[candidate.kind] > RANK$1[best.kind]) best = candidate;
+			if (best.kind === "breaking") break;
+		}
+		return best ?? {
+			kind: "none",
+			reason: "no changes"
+		};
+	}
+});
+//#endregion
+//#region src/steps/labels/determine-notes.ts
+/**
+* A `### Title` section per group of labels, like GitHub's own release notes
+* categories, then the rest.
+*/
+const labelsBuildNotes = defineStep({
+	phase: "determine-notes",
+	name: "labels/determine-notes",
+	description: "A `### Title` section per group of labels, e.g. `### Bug Fixes` for `bug`, then `### Other` for everything else.",
+	needs: ["changes.labels"],
+	options: {
+		sections: z.array(z.strictObject({
+			title: z.string(),
+			labels: z.array(z.string())
+		})).default([
+			{
+				title: "Breaking Changes",
+				labels: ["breaking", "semver:major"]
+			},
+			{
+				title: "Features",
+				labels: ["feature", "enhancement"]
+			},
+			{
+				title: "Bug Fixes",
+				labels: ["bug", "fix"]
+			}
+		]).describe("Sections in order; a change goes in the first with one of its labels, ignoring case."),
+		other: z.union([z.string(), z.literal(false)]).default("Other").describe("The section for remaining changes; `false` leaves them out."),
+		exclude: z.array(z.string()).default(["skip-changelog"]).describe("Changes with any of these labels are left out."),
+		descriptions: z.boolean().default(false).describe("Write each change's description, indented, under it."),
+		links: z.boolean().default(true).describe("Link each change to its source, e.g. its pull request."),
+		dependencies: dependenciesOption
+	},
+	run: ({ changes, kind, dependencies, options }) => {
+		const sections = [...options.sections, ...options.other === false ? [] : [{ title: options.other }]].map((section) => ({
+			...section,
+			entries: []
+		}));
+		for (const change of changes) {
+			if (hasLabel(change, options.exclude)) continue;
+			const target = sections.find((section) => !("labels" in section) || hasLabel(change, section.labels));
+			const entry = format(change, options);
+			if (target && entry !== void 0) target.entries.push(entry);
+		}
+		return joinSections(kind, [...sections, ...dependencySection(options.dependencies, dependencies)]);
+	}
+});
+function format(change, style) {
+	const lines = (change.title ?? change.description ?? "").trim().split("\n");
+	const text = lines[0]?.trim();
+	if (!text) return void 0;
+	const link = style.links && change.link ? ` ([${change.link.label}](${change.link.url}))` : "";
+	const details = (change.title === void 0 ? lines.slice(1) : [change.description ?? ""]).join("\n").trim();
+	return `- ${text}${link}${style.descriptions && details ? `\n${details.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n")}` : ""}`;
+}
+//#endregion
+//#region src/steps/npm/publish.ts
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+/**
+* Publishes the package to npm, after earlier steps wrote the new version to
+* `package.json`. Lifecycle scripts like `prepublishOnly` run as usual.
+*/
+const npmPublish = defineStep({
+	phase: "release",
+	name: "npm/publish",
+	description: "Publishes the component's package to the npm registry with `npm` or `pnpm publish`; components are published dependencies first.",
+	needs: ["version.semver"],
+	options: {
+		path: z.string().default(".").describe("The package's directory, relative to the component's."),
+		client: z.enum(["npm", "pnpm"]).optional().describe("Defaults to the `packageManager` in package.json, then `pnpm` if there's a `pnpm-lock.yaml`, then `npm`."),
+		tag: z.string().optional().describe("The dist-tag; defaults to the channel's name on a channel, then `publishConfig.tag`, or `latest`."),
+		access: z.enum(["public", "restricted"]).optional().describe("Defaults to `publishConfig.access`."),
+		provenance: z.boolean().default(false).describe("Publishes with a provenance statement; needs `id-token: write`."),
+		registry: z.string().optional().describe("Defaults to `publishConfig.registry`, or the npm registry."),
+		token: z.string().optional().describe("Defaults to `NPM_TOKEN` or `NODE_AUTH_TOKEN`; without one, the client's own auth is used, e.g. trusted publishing.")
+	},
+	run: async ({ env, component, version, options }) => {
+		const { file: dir, relative } = inComponent(env, component, options.path);
+		const manifest = posix.join(relative, "package.json");
+		const json = await loadJson(join(dir, "package.json"));
+		const name = typeof json.name === "string" ? json.name : void 0;
+		if (!name) throw new Error(`${manifest} has no 'name'`);
+		if (json.private === true) throw new Error(`${manifest} is private; npm won't publish it`);
+		const publishConfig = json.publishConfig ?? {};
+		const registry = options.registry ?? (typeof publishConfig.registry === "string" ? publishConfig.registry : DEFAULT_REGISTRY);
+		const client = options.client ?? await detectClient(dir, json);
+		const tag = options.tag ?? env.channel?.name ?? (typeof publishConfig.tag === "string" ? publishConfig.tag : "latest");
+		const target = `${name}@${version} to ${registry} as ${tag}`;
+		const output = {
+			name,
+			version,
+			client,
+			tag,
+			registry
+		};
+		if (env.dryRun) return {
+			output: {
+				...output,
+				published: false
+			},
+			reason: `would ${client} publish ${target}`
+		};
+		const current = versionOf(json, manifest);
+		if (current !== version) throw new Error(`${manifest} is at ${current}, not ${version}; write it first (npm/write-version)`);
+		const args = [
+			"publish",
+			"--registry",
+			registry,
+			"--tag",
+			tag
+		];
+		if (options.access) args.push("--access", options.access);
+		if (options.provenance) args.push("--provenance");
+		if (client === "pnpm") args.push("--no-git-checks");
+		await withToken(options.token ?? process.env.NPM_TOKEN ?? process.env.NODE_AUTH_TOKEN, registry, (env) => exec(client, args, {
+			cwd: dir,
+			env
+		}));
+		return {
+			output: {
+				...output,
+				published: true
+			},
+			reason: `published ${target}`
+		};
+	}
+});
+async function detectClient(dir, json) {
+	if (typeof json.packageManager === "string") return json.packageManager.startsWith("pnpm@") ? "pnpm" : "npm";
+	for (let current = dir;; current = dirname(current)) {
+		if (await exists(join(current, "pnpm-lock.yaml"))) return "pnpm";
+		if (await exists(join(current, "package-lock.json"))) return "npm";
+		if (dirname(current) === current) return "npm";
+	}
+}
+function exists(path) {
+	return access(path).then(() => true, () => false);
+}
+/**
+* Runs `run` with an environment that authenticates to the registry with the
+* token, if there is one: a copy of the user's npmrc with the token's key
+* added, which both npm and pnpm read. The token itself stays in the
+* environment, never on disk.
+*/
+async function withToken(token, registry, run) {
+	if (!token) return run(process.env);
+	const userconfig = process.env.NPM_CONFIG_USERCONFIG ?? process.env.npm_config_userconfig ?? join(homedir(), ".npmrc");
+	const existing = await readFile(userconfig, "utf8").catch(() => "");
+	const dir = await mkdtemp(join(tmpdir(), "rylease-npmrc-"));
+	try {
+		const npmrc = join(dir, ".npmrc");
+		await writeFile(npmrc, `${existing.trimEnd()}\n${authKey(registry)}=\${RYLEASE_NPM_TOKEN}\n`.trimStart());
+		const { npm_config_userconfig: _, ...env } = process.env;
+		return await run({
+			...env,
+			NPM_CONFIG_USERCONFIG: npmrc,
+			RYLEASE_NPM_TOKEN: token
+		});
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** The npmrc key of a registry's token, e.g. `//registry.npmjs.org/:_authToken`. */
+function authKey(registry) {
+	const url = new URL(registry);
+	const path = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
+	return `//${url.host}${path}:_authToken`;
+}
+//#endregion
+//#region src/steps/index.ts
+var steps_exports = /* @__PURE__ */ __exportAll({
+	changeFilesClean: () => changeFilesClean,
+	changeFilesRead: () => changeFilesRead,
+	componentsDependents: () => componentsDependents,
+	conventionalBuildNotes: () => conventionalBuildNotes,
+	conventionalDetermineKind: () => conventionalDetermineKind,
+	conventionalReadCommits: () => conventionalReadCommits,
+	execCommand: () => execCommand,
+	fsWriteChanges: () => fsWriteChanges,
+	fsWriteVersion: () => fsWriteVersion,
+	gitCommit: () => gitCommit,
+	gitCreateTag: () => gitCreateTag,
+	githubCreateRelease: () => githubCreateRelease,
+	githubOpenReleasePr: () => githubOpenReleasePr,
+	githubReadPullRequests: () => githubReadPullRequests,
+	githubUploadArtifact: () => githubUploadArtifact,
+	githubUploadReleaseAssets: () => githubUploadReleaseAssets,
+	gitlabCreateRelease: () => gitlabCreateRelease,
+	keepAChangelogReadUnreleased: () => keepAChangelogReadUnreleased,
+	keepAChangelogWriteRelease: () => keepAChangelogWriteRelease,
+	labelsBuildNotes: () => labelsBuildNotes,
+	labelsDetermineKind: () => labelsDetermineKind,
+	npmPublish: () => npmPublish
+});
+//#endregion
+//#region src/presets/change-files.ts
+/**
+* Change files in `.changes/` → notes by kind → the changelog written and
+* the change files deleted, committed and tagged → GitHub release. Each
+* file names the components it changes and how much, so a monorepo's
+* releases don't depend on commit messages. Add files with `rylease add`.
+* Releases are found by their tags; set the release's `scheme`.
+*/
+const changeFiles = definePreset({
+	name: "change-files",
+	description: "Change files in `.changes/` → changelog written and change files deleted, committed, git tag and GitHub release.",
+	steps: [
+		changeFilesRead,
+		labelsDetermineKind,
+		labelsBuildNotes,
+		changeFilesClean,
+		fsWriteChanges,
+		gitCommit,
+		gitCreateTag,
+		githubCreateRelease
+	],
+	defaults: {
+		"labels/determine-kind": { kinds: {
+			breaking: "breaking",
+			feature: "feature",
+			fix: "fix",
+			none: "none"
+		} },
+		"labels/determine-notes": {
+			sections: [
+				{
+					title: "Breaking Changes",
+					labels: ["breaking"]
+				},
+				{
+					title: "Features",
+					labels: ["feature"]
+				},
+				{
+					title: "Fixes",
+					labels: ["fix"]
+				}
+			],
+			other: false,
+			exclude: ["none"],
+			descriptions: true
+		},
+		"git/create-tag": { push: "origin" }
+	},
+	history: gitTags
+});
+//#endregion
+//#region src/schemes/calver.ts
+/** The date tokens of calver.org, by what they're made from. */
+const DATES = {
+	YYYY: (date) => String(date.year),
+	YY: (date) => String(date.year - 2e3),
+	"0Y": (date) => String(date.year - 2e3).padStart(2, "0"),
+	MM: (date) => String(date.month),
+	"0M": (date) => String(date.month).padStart(2, "0"),
+	WW: (date) => String(date.week),
+	"0W": (date) => String(date.week).padStart(2, "0"),
+	DD: (date) => String(date.day),
+	"0D": (date) => String(date.day).padStart(2, "0")
+};
+/** Counters, from the kind each one is bumped for. */
+const COUNTERS = {
+	MAJOR: "breaking",
+	MINOR: "feature",
+	MICRO: "fix"
+};
+const RANK = {
+	fix: 0,
+	feature: 1,
+	breaking: 2
+};
+const TOKENS = [...Object.keys(DATES), ...Object.keys(COUNTERS)];
+/**
+* Calendar versioning, as on calver.org: the format's date tokens come from
+* the release date, and its counters (`MAJOR`, `MINOR`, `MICRO`) number the
+* releases within the same period. A counter is bumped by the kind it stands
+* for (`breaking`, `feature`, `fix`), or by a higher kind when the format has
+* no counter for that; the counters after it start again from 0, as do all of
+* them in a new period.
+*/
+const calver = defineScheme({
+	name: "calver",
+	description: "Dates the version, as on calver.org, e.g. `YYYY.MM.MICRO` → `2026.10.0`; a counter numbers releases in the same period, bumped by the kind.",
+	options: {
+		format: z.string().default("YYYY.MM.MICRO").refine((format) => format.split(".").every((token) => TOKENS.includes(token)) && new Set(format.split(".")).size === format.split(".").length, `must be distinct tokens joined by '.', of ${TOKENS.join(", ")}`).refine((format) => format.split(".").some((token) => token in DATES), "must have a date token, e.g. YYYY").describe("Tokens joined by `.`: `YYYY`, `YY`, `0Y`, `MM`, `0M`, `WW`, `0W`, `DD`, `0D` (ISO 8601 weeks, with the ISO year), and the counters `MAJOR`, `MINOR`, `MICRO`. Zero-padded tokens (`0M` …) aren't valid semver, which npm needs."),
+		timezone: z.string().default("UTC").refine(isTimezone, "must be an IANA time zone, e.g. Europe/Berlin").describe("Where the release date is taken, e.g. `America/New_York`.")
+	},
+	create: (options) => {
+		const format = options.format.split(".");
+		const matches = (version) => {
+			const parts = version.trim().split(".");
+			return parts.length === format.length && parts.every((part, i) => SHAPES[format[i]].test(part));
+		};
+		const padded = format.some((token) => token.startsWith("0"));
+		return {
+			name: `calver ${options.format}`,
+			traits: padded ? [] : ["version.semver"],
+			matches,
+			compare: (a, b) => compareVersions(parseVersion(a), parseVersion(b)),
+			bump: ({ previous, kind, date: now }) => {
+				const date = dateParts(now, options.timezone, format);
+				const before = previous?.split(".").map(Number);
+				const samePeriod = before !== void 0 && format.every((token, i) => !(token in DATES) || Number(DATES[token](date)) === before[i]);
+				const counters = format.filter((token) => Object.hasOwn(COUNTERS, token));
+				const bumped = samePeriod ? bumpedCounter(counters, kind) : void 0;
+				if (samePeriod && bumped === void 0) throw new Error(`${previous} is already this period's release; add a counter (e.g. MICRO) to '${options.format}' to release more often`);
+				return {
+					version: format.map((token, i) => {
+						if (token in DATES) return DATES[token](date);
+						if (!samePeriod || bumped === void 0) return "0";
+						const index = format.indexOf(bumped);
+						if (i < index) return String(before?.[i]);
+						return i === index ? String((before?.[i] ?? 0) + 1) : "0";
+					}).join("."),
+					reason: previous === void 0 ? "first release" : samePeriod ? `bumps ${bumped}` : "new period"
+				};
+			},
+			fields: (version) => Object.fromEntries(format.map((token, i) => [token, version.split(".")[i] ?? ""]))
+		};
+	}
+});
+/** What each token looks like in a version. */
+const SHAPES = {
+	YYYY: /^[1-9]\d{3}$/,
+	YY: /^(0|[1-9]\d*)$/,
+	"0Y": /^\d{2,}$/,
+	MM: /^([1-9]|1[0-2])$/,
+	"0M": /^(0[1-9]|1[0-2])$/,
+	WW: /^([1-9]|[1-4]\d|5[0-3])$/,
+	"0W": /^(0[1-9]|[1-4]\d|5[0-3])$/,
+	DD: /^([1-9]|[12]\d|3[01])$/,
+	"0D": /^(0[1-9]|[12]\d|3[01])$/,
+	MAJOR: /^(0|[1-9]\d*)$/,
+	MINOR: /^(0|[1-9]\d*)$/,
+	MICRO: /^(0|[1-9]\d*)$/
+};
+/**
+* The counter a kind bumps: its own, or the nearest one below it, or else the
+* lowest the format has (e.g. `MINOR` alone takes fixes too).
+*/
+function bumpedCounter(counters, kind) {
+	const ranked = [...counters].sort((a, b) => RANK[COUNTERS[b]] - RANK[COUNTERS[a]]);
+	return ranked.find((counter) => RANK[COUNTERS[counter]] <= RANK[kind]) ?? ranked.at(-1);
+}
+function dateParts(now, timezone, format) {
+	const fields = Object.fromEntries(new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		year: "numeric",
+		month: "numeric",
+		day: "numeric"
+	}).formatToParts(now).map(({ type, value }) => [type, Number(value)]));
+	const iso = isoWeek(fields.year, fields.month, fields.day);
+	const weekly = format.includes("WW") || format.includes("0W");
+	return {
+		...fields,
+		year: weekly ? iso.year : fields.year,
+		week: iso.week
+	};
+}
+/** The ISO 8601 week of a date, and the year that week belongs to. */
+function isoWeek(year, month, day) {
+	const date = new Date(Date.UTC(year, month - 1, day));
+	date.setUTCDate(date.getUTCDate() + 3 - weekday(date));
+	const weekYear = date.getUTCFullYear();
+	const first = new Date(Date.UTC(weekYear, 0, 4));
+	first.setUTCDate(first.getUTCDate() + 3 - weekday(first));
+	const weeks = (date.getTime() - first.getTime()) / 6048e5;
+	return {
+		year: weekYear,
+		week: 1 + Math.round(weeks)
+	};
+}
+/** Monday is 0. */
+function weekday(date) {
+	return (date.getUTCDay() + 6) % 7;
+}
+function isTimezone(timezone) {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/schemes/index.ts
+var schemes_exports = /* @__PURE__ */ __exportAll({
+	bumpSemver: () => bumpSemver,
+	calver: () => calver,
+	formatSemver: () => formatSemver,
+	isSemver: () => isSemver,
+	parseSemver: () => parseSemver,
+	semver: () => semver
+});
+//#endregion
+//#region src/presets/conventional.ts
+/**
+* Conventional commits since the previous release → git tag → GitHub
+* release, versioned by semver and found by its tags. Nothing specific to a
+* language or ecosystem; add steps like `fs/write-version`,
+* `fs/write-changes` and `git/commit` for that. The tag is pushed, with the
+* branch, to `origin`.
+*/
+const conventional = definePreset({
+	name: "conventional",
+	description: "Conventional commits → notes → git tag and GitHub release.",
+	steps: [
+		conventionalReadCommits,
+		conventionalDetermineKind,
+		conventionalBuildNotes,
+		gitCreateTag,
+		githubCreateRelease
+	],
+	defaults: { "git/create-tag": { push: "origin" } },
+	scheme: semver,
+	history: gitTags
+});
+//#endregion
+//#region src/presets/conventional-pr.ts
+/**
+* Conventional commits → the changelog written and proposed in a release
+* pull request, kept up to date with each push; merging it tags the release
+* and creates its GitHub release. Versioned by semver; its history,
+* `github/release-pr`, is how the run on the merge finds what the pull
+* request proposed.
+*/
+const conventionalPr = definePreset({
+	name: "conventional-pr",
+	description: "Conventional commits → changelog proposed in a release pull request; merging it tags the release and creates its GitHub release.",
+	steps: [
+		conventionalReadCommits,
+		conventionalDetermineKind,
+		conventionalBuildNotes,
+		fsWriteChanges,
+		githubOpenReleasePr,
+		gitCreateTag,
+		githubCreateRelease
+	],
+	defaults: { "git/create-tag": { push: "origin" } },
+	scheme: semver,
+	history: githubReleasePr
+});
+/**
+* `## [Unreleased]` in CHANGELOG.md → the changelog released, committed and
+* tagged → GitHub release. Each entry's kind comes from its section:
+* `Removed` is breaking, `Added`, `Changed` and `Deprecated` features, and
+* the rest fixes. Releases are found by their tags; set the release's
+* `scheme`, e.g. `semver()`, or `calver()` to date them.
+*/
+const keepAChangelog = definePreset({
+	name: "keep-a-changelog",
+	description: "`## [Unreleased]` in CHANGELOG.md → changelog committed, git tag and GitHub release.",
+	steps: [
+		keepAChangelogReadUnreleased,
+		labelsDetermineKind,
+		labelsBuildNotes,
+		keepAChangelogWriteRelease,
+		gitCommit,
+		gitCreateTag,
+		githubCreateRelease
+	],
+	defaults: {
+		"labels/determine-kind": { kinds: {
+			Removed: "breaking",
+			Added: "feature",
+			Changed: "feature",
+			Deprecated: "feature"
+		} },
+		"labels/determine-notes": {
+			sections: [
+				"Added",
+				"Changed",
+				"Deprecated",
+				"Removed",
+				"Fixed",
+				"Security"
+			].map((title) => ({
+				title,
+				labels: [title]
+			})),
+			descriptions: true
+		},
+		"git/create-tag": { push: "origin" }
+	},
+	history: gitTags
+});
+//#endregion
+//#region src/presets/index.ts
+var presets_exports = /* @__PURE__ */ __exportAll({
+	changeFiles: () => changeFiles,
+	conventional: () => conventional,
+	conventionalPr: () => conventionalPr,
+	keepAChangelog: () => keepAChangelog
+});
+//#endregion
+//#region src/config/workflow.ts
+const builtins = new Map([
+	...Object.values(steps_exports),
+	...Object.values(presets_exports),
+	...Object.values(schemes_exports),
+	...Object.values(histories_exports),
+	...Object.values(components_exports)
+].filter((item) => isFactory(item)).map((item) => [item.name, item]));
+const CHANNELS = z.record(z.string(), z.strictObject({
+	branches: z.array(z.string()).optional(),
+	type: z.enum(["prerelease", "build"]).optional(),
+	format: z.string().optional()
+}));
+/**
+* Turns a workflow's inputs into a release: its `steps`, and how versions are
+* made (`scheme`), tagged (`tag`), found (`history`), and of what
+* (`components`). Each of those but `tag` names what it `uses` and passes
+* it options `with`, or is just a name:
+*
+* ```yaml
+* scheme: { uses: calver, with: { format: YY.MINOR.MICRO } }
+* components: npm/workspaces
+* ```
+*/
+async function resolveWorkflow(input, options) {
+	const scheme = input.scheme == null ? void 0 : await create(input.scheme, "scheme", "scheme", options.cwd);
+	const history = input.history == null ? void 0 : await Promise.all((Array.isArray(input.history) ? input.history : [input.history]).map((entry, index) => create(entry, "history", Array.isArray(input.history) ? `history[${index}]` : "history", options.cwd)));
+	if (input.tag != null && typeof input.tag !== "string") throw new OptionsError(["tag: expected a template, e.g. v{version}"]);
+	return {
+		steps: await resolveWorkflowSteps(input.steps, options),
+		...scheme && { scheme },
+		...typeof input.tag === "string" && input.tag !== "" && { tag: input.tag },
+		...history && { history },
+		...input.components != null && { components: await resolveComponentsInput(input.components, options.cwd) },
+		...input.channels != null && { channels: parseChannels(input.channels) }
+	};
+}
+function parseChannels(value) {
+	const result = CHANNELS.safeParse(value);
+	if (result.success) return result.data;
+	throw new OptionsError(result.error.issues.map((issue) => `${joinPath("channels", issue.path)}: ${issue.message}`));
+}
+async function resolveComponentsInput(value, cwd) {
+	if (!Array.isArray(value)) return create(value, "components", "components", cwd);
+	const keys = [
+		"name",
+		"path",
+		"dependsOn",
+		"tag",
+		"scheme",
+		"history"
+	];
+	const components = [];
+	for (const [index, entry] of value.entries()) {
+		const at = `components[${index}]`;
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new OptionsError([`${at}: expected a map with 'name' and 'path'`]);
+		const fields = entry;
+		const unknown = Object.keys(fields).filter((key) => !keys.includes(key));
+		if (unknown.length > 0) throw new OptionsError(unknown.map((key) => `${at}.${key}: unknown key; use ${keys.join(", ")}`));
+		const text = (key) => {
+			const field = fields[key];
+			if (field != null && typeof field !== "string") throw new OptionsError([`${at}.${key}: expected text`]);
+			return field ?? void 0;
+		};
+		const dependsOn = fields.dependsOn;
+		if (dependsOn != null && !(Array.isArray(dependsOn) && dependsOn.every((item) => typeof item === "string"))) throw new OptionsError([`${at}.dependsOn: expected a list of component names`]);
+		const name = text("name");
+		const path = text("path");
+		const tag = text("tag");
+		components.push({
+			name: name ?? "",
+			...path !== void 0 && { path },
+			...tag !== void 0 && { tag },
+			...dependsOn != null && { dependsOn },
+			...fields.scheme != null && { scheme: await create(fields.scheme, "scheme", `${at}.scheme`, cwd) },
+			...fields.history != null && { history: await create(fields.history, "history", `${at}.history`, cwd) }
+		});
+	}
+	return components;
+}
+/** Creates a scheme, history or component source from `name` or `{ uses, with }`. */
+async function create(value, kind, at, cwd) {
+	const entry = typeof value === "string" ? {
+		uses: value,
+		with: void 0
+	} : value;
+	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new OptionsError([`${at}: expected a name, or a map with 'uses' and 'with'`]);
+	const fields = entry;
+	const unknown = Object.keys(fields).filter((key) => key !== "uses" && key !== "with");
+	if (unknown.length > 0) throw new OptionsError(unknown.map((key) => `${at}.${key}: unknown key; use uses, with`));
+	if (typeof fields.uses !== "string" || fields.uses === "") throw new OptionsError([`${at}.uses: expected the name of a ${kind === "components" ? "component source" : kind}`]);
+	const target = await load(fields.uses, `${at}.uses`, cwd);
+	if (target.kind !== kind) throw new OptionsError([`${at}.uses: '${fields.uses}' is a ${target.kind}, not a ${kind === "components" ? "component source" : kind}`]);
+	try {
+		return target(fields.with ?? void 0);
+	} catch (error) {
+		if (!(error instanceof OptionsError)) throw error;
+		throw new OptionsError(error.issues.map((issue) => `${at}.with${issue.startsWith(target.name) ? issue.slice(target.name.length) : `: ${issue}`}`));
+	}
+}
+/**
+* Turns workflow `steps` (already parsed from YAML) into steps. Each entry
+* names what it `uses`, passes it options `with`, and may run only `if` an
+* expression holds:
+*
+* ```yaml
+* - uses: conventional              # a bundled preset or step
+*   with:
+*     github/create-release: false
+* - uses: ./release/announce.ts     # a file's default export
+*   if: "!dryRun && kind != 'patch'"
+*   with:
+*     channel: "#releases"
+* - uses: some-package#slackNotes   # a package's named export
+* ```
+*/
+async function resolveWorkflowSteps(entries, options) {
+	if (!Array.isArray(entries)) throw new OptionsError(["steps: expected a list of steps"]);
+	const parsed = entries.map((entry, index) => parseEntry(entry, index));
+	const steps = [];
+	const fromPreset = /* @__PURE__ */ new Map();
+	const explicit = [];
+	for (const { uses, with: value, condition, at } of parsed) {
+		const target = await load(uses, `${at}.uses`, options.cwd);
+		if (target.kind !== "step" && target.kind !== "preset") throw new OptionsError([`${at}.uses: '${uses}' is a ${target.kind}, not a step; set it as \`${target.kind}\` instead`]);
+		let created;
+		try {
+			if (isPreset(target)) {
+				created = target(value);
+				for (const step of created) fromPreset.set(step.name, target.name);
+			} else {
+				created = [target(value)];
+				explicit.push({
+					name: target.name,
+					at
+				});
+			}
+		} catch (error) {
+			if (!(error instanceof OptionsError)) throw error;
+			throw new OptionsError(error.issues.map((issue) => `${at}.with${issue.startsWith(target.name) ? issue.slice(target.name.length) : `: ${issue}`}`));
+		}
+		steps.push(...created.map((step) => condition ? when(step, condition) : step));
+	}
+	const twice = explicit.flatMap(({ name, at }) => {
+		const preset = fromPreset.get(name);
+		return preset ? [`${at}.uses: '${name}' is already in '${preset}'; configure it there (with: { ${name}: ... }), or set it to false there to replace it`] : [];
+	});
+	if (twice.length > 0) throw new OptionsError(twice);
+	return steps;
+}
+const ENTRY_KEYS = [
+	"uses",
+	"with",
+	"if"
+];
+function parseEntry(entry, index) {
+	const at = `steps[${index}]`;
+	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new OptionsError([`${at}: expected a map with 'uses', and optionally 'with' and 'if'`]);
+	const fields = entry;
+	const unknown = Object.keys(fields).filter((key) => !ENTRY_KEYS.includes(key));
+	if (unknown.length > 0) throw new OptionsError(unknown.map((key) => `${at}.${key}: unknown key; use ${ENTRY_KEYS.join(", ")}`));
+	if (typeof fields.uses !== "string" || fields.uses === "") throw new OptionsError([`${at}.uses: expected the name of a step or preset`]);
+	if (fields.with != null && (typeof fields.with !== "object" || Array.isArray(fields.with))) throw new OptionsError([`${at}.with: expected a map of options`]);
+	const condition = parseCondition(fields.if, `${at}.if`);
+	return {
+		uses: fields.uses,
+		with: fields.with ?? void 0,
+		...condition && { condition },
+		at
+	};
+}
+/**
+* `if:` is a rylease expression, or a boolean, e.g. what GitHub made of
+* `${{ ... }}` before rylease ran.
+*/
+function parseCondition(value, at) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "boolean") return Object.assign(() => value, { source: String(value) });
+	if (typeof value !== "string") throw new OptionsError([`${at}: expected an expression or a boolean`]);
+	try {
+		const evaluate = compileExpression(value);
+		return Object.assign((input) => Boolean(evaluate(expressionContext(input))), { source: value });
+	} catch (error) {
+		if (!(error instanceof ExpressionError)) throw error;
+		throw new OptionsError([`${at}: ${error.message} in \`${value}\``]);
+	}
+}
+async function load(name, path, cwd) {
+	const builtin = builtins.get(name);
+	if (builtin) return builtin;
+	const [specifier = name, exportName = "default"] = name.split("#");
+	const isPath = /^\.{0,2}\//.test(specifier);
+	let url;
+	try {
+		url = isPath ? pathToFileURL(resolve(cwd, specifier)).href : pathToFileURL(createRequire(join(cwd, "package.json")).resolve(specifier)).href;
+	} catch {
+		throw new OptionsError([`${path}: unknown step ${name}; use one of ${[...builtins.keys()].join(", ")}, a path like ./steps/x.ts, or an installed package`]);
+	}
+	const target = (await import(url))[exportName];
+	if (isFactory(target)) return target;
+	throw new OptionsError([`${path}: export '${exportName}' of ${specifier} isn't made with defineStep, definePreset, defineScheme, defineHistory or defineComponents`]);
+}
+function isPreset(value) {
+	return value.kind === "preset";
+}
+//#endregion
+//#region src/core/summary.ts
+const ICONS = {
+	ok: "✅",
+	skipped: "⚪",
+	failed: "❌"
+};
+/**
+* The report as Markdown, for GitHub's job summary: what happened, a row per
+* step, and the release notes.
+*/
+function markdownSummary(report) {
+	const dryRun = report.env.dryRun;
+	const several = report.components.length > 1;
+	const describe = (component) => {
+		const from = component.previousVersion ?? "nothing";
+		const to = component.version ?? "?";
+		if (component.status !== "released" && component.status !== "pending") return `**${from}** · nothing to release`;
+		return `${from === to ? `**${to}**` : `**${from}** → **${to}** (${component.kind})`} · ${component.status === "pending" ? dryRun ? "would be proposed" : "proposed" : dryRun ? "would release" : "released"}`;
+	};
+	const [only] = report.components;
+	const headline = report.status === "failed" ? "release failed" : !several && only ? describe(only) : report.status === "released" ? dryRun ? "would release" : "released" : report.status === "pending" ? dryRun ? "would be proposed" : "proposed" : "nothing to release";
+	const lines = [
+		`### ${report.status === "failed" ? "❌ " : ""}rylease${dryRun ? " dry run" : ""} · ${headline}`,
+		"",
+		`On \`${report.env.branch}\`${report.env.channel ? `, on the \`${report.env.channel.name}\` channel` : ""}${dryRun ? ", without side effects" : ""}.${report.deferred ? ` ${report.deferred[0]?.toUpperCase()}${report.deferred.slice(1)}.` : ""}`,
+		...several && report.status !== "failed" ? ["", ...report.components.map((component) => `- \`${component.name}\`: ${describe(component)}`)] : [],
+		"",
+		several ? "| | Component | Type | Step | Time | |" : "| | Type | Step | Time | |",
+		several ? "|:-:|---|---|---|--:|---|" : "|:-:|---|---|--:|---|",
+		...report.records.map((record) => `| ${ICONS[record.status]} |${several ? ` ${record.component ? `\`${record.component}\`` : "all"} |` : ""} \`${record.phase}\` | \`${record.name}\` | ${record.status === "skipped" ? "" : formatDuration(record.durationMs)} | ${cell(record.reason)} |`)
+	];
+	for (const component of report.components) {
+		if (report.status === "failed" || report.status === "unchanged") continue;
+		if (component.status !== "released" && component.status !== "pending") continue;
+		if (!component.notes?.trim()) continue;
+		lines.push("", `<details open><summary>Release notes${several ? ` of ${component.name} ${component.version}` : ""}</summary>`, "", component.notes.trim(), "", "</details>");
+	}
+	return `${lines.join("\n")}\n\n`;
+}
+/** Text that stays inside one table cell or list item. */
+function cell(text) {
+	return text.replaceAll("|", "\\|").replaceAll("<", "&lt;").replace(/\r?\n/g, "<br>");
+}
+//#endregion
+export { KINDS, OptionsError, PHASES, ReleaseError, compileExpression, components_exports as components, defaultReporter, defineComponents, defineHistory, definePreset, defineRelease, defineScheme, defineStep, errorMessage, expressionContext, formatDuration, git, histories_exports as histories, joinPath, markdownSummary, parseOptions, presets_exports as presets, prettyReporter, resolveComponents, resolveWorkflow, resolveWorkflowSteps, runRelease, schemes_exports as schemes, sortSteps, steps_exports as steps, tryGit, when, z };
+
+//# sourceMappingURL=index.mjs.map