rylease 3.0.0 → 3.1.0

package/dist/index.mjs

@@ -1,4928 +1 @@
-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
+export { C as KINDS, P as OptionsError, w as PHASES, y as ReleaseError, p as compileExpression, j as components, T as defaultReporter, M as defineComponents, f as defineHistory, h as definePreset, g as defineRelease, c as defineScheme, _ as defineStep, b as errorMessage, m as expressionContext, E as formatDuration, k as git, d as histories, F as joinPath, n as markdownSummary, I as parseOptions, a as presets, D as prettyReporter, N as resolveComponents, r as resolveWorkflow, i as resolveWorkflowSteps, x as runRelease, o as schemes, S as sortSteps, s as steps, A as tryGit, v as when, L as z } from "./src-BkALSGzm.mjs";