rylease 3.0.0 → 3.2.0

package/dist/index-CDKUm2-t.d.mts

@@ -0,0 +1,1671 @@
+import * as z from "zod";
+import * as core from "zod/v4/core";
+//#region src/core/options.d.ts
+/** A step's options: a zod shape, from `zod` or `zod/mini`. */
+type OptionsShape = core.$ZodShape;
+/** What a step accepts: options with a default may be left out. */
+type OptionsInput<S extends OptionsShape> = core.$InferObjectInput<S, Empty>;
+/** What a step's `run` receives: every default applied. */
+type OptionsValue<S extends OptionsShape> = core.$InferObjectOutput<S, Empty>;
+/** An object type with no properties. */
+type Empty = Record<never, never>;
+/** Options that don't match a step's schema; the message lists every problem. */
+declare class OptionsError extends Error {
+  readonly issues: readonly string[];
+  constructor(issues: readonly string[]);
+}
+/**
+ * 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: ...`.
+ */
+declare function parseOptions<S extends OptionsShape>(shape: S, value: unknown, path: string): OptionsValue<S>;
+declare function joinPath(path: string, keys?: readonly PropertyKey[]): string;
+//#endregion
+//#region src/components/cargo/workspaces.d.ts
+/**
+ * The crates of a Cargo workspace, as components named after them, each
+ * depending on the workspace crates it lists as dependencies.
+ */
+declare const cargoWorkspaces: Factory<"components", "cargo/workspaces", {
+  private: z.ZodDefault<z.ZodBoolean>;
+  exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, ComponentSource>;
+//#endregion
+//#region src/components/dart/workspaces.d.ts
+/**
+ * The packages of a pub workspace, or a Melos one, as components named after
+ * them, each depending on the workspace packages it lists as dependencies.
+ * The root is one too when it has a `version`, e.g. a Flutter app whose
+ * packages live beside it.
+ */
+declare const dartWorkspaces: Factory<"components", "dart/workspaces", {
+  private: z.ZodDefault<z.ZodBoolean>;
+  exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, ComponentSource>;
+//#endregion
+//#region src/components/npm/workspaces.d.ts
+/**
+ * The packages of an npm, Yarn or pnpm workspace, as components named after
+ * them, each depending on the workspace packages it lists as dependencies.
+ */
+declare const npmWorkspaces: Factory<"components", "npm/workspaces", {
+  private: z.ZodDefault<z.ZodBoolean>;
+  exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, ComponentSource>;
+declare namespace index_d_exports$4 {
+  export { cargoWorkspaces, dartWorkspaces, npmWorkspaces };
+}
+//#endregion
+//#region src/core/factory.d.ts
+/** What a factory makes: a step, preset, scheme, history or component source. */
+type FactoryKind = "step" | "preset" | "scheme" | "history" | "components";
+/**
+ * Something configured with options declared as a zod shape, the same way in
+ * TypeScript as in a workflow file; the options argument is optional when
+ * every option is.
+ */
+interface Factory<K extends FactoryKind, N extends string, S extends OptionsShape, R> {
+  (...options: Empty extends OptionsInput<S> ? [options?: OptionsInput<S>] : [options: OptionsInput<S>]): R;
+  readonly kind: K;
+  readonly name: N;
+  readonly description: string | undefined;
+  readonly options: S;
+}
+/** Any factory of a kind, whatever its name or options. */
+interface AnyFactory<K extends FactoryKind = FactoryKind, R = unknown> {
+  (options?: any): R;
+  readonly kind: K;
+  readonly name: string;
+  readonly description: string | undefined;
+  readonly options: OptionsShape;
+}
+interface FactoryDefinition<N extends string, S extends OptionsShape, R> {
+  /** Identifies it in reports and in workflow files, e.g. `calver`. */
+  name: N;
+  /** One line on what it does, for generated docs. */
+  description?: string;
+  /** A zod shape; use `.default()` for optional options and `.describe()` to document them. */
+  options?: S;
+  create: (options: OptionsValue<S>) => R;
+}
+//#endregion
+//#region src/core/history.d.ts
+/** Where a component's previous release is found: tags, a file, ... */
+interface History {
+  readonly name: string;
+  find(input: HistoryInput): Promise<Found | undefined>;
+  /**
+   * The highest counter of a channel's versions of a target, among every
+   * release, not only those on HEAD, so channel versions never collide.
+   */
+  count?(input: HistoryInput & {
+    target: string;
+  }): Promise<number>;
+  /** Whether a release's tag exists already. */
+  exists?(input: HistoryInput & {
+    releaseTag: string;
+  }): Promise<boolean>;
+}
+interface HistoryInput {
+  env: Environment;
+  component: ComponentInfo;
+  scheme: Scheme;
+  /** The component's tag template, with `{name}` filled in, e.g. `v{version}`. */
+  tag: string;
+  /** The channel being released on; without one, only stable releases count. */
+  channel?: ResolvedChannel | undefined;
+  /** Every channel, to tell their versions from stable ones. */
+  channels: readonly ResolvedChannel[];
+}
+/** The previous release; `undefined` from `find` when there's none. */
+interface Found {
+  /** Absent when the release's version isn't one of the scheme's. */
+  version?: string;
+  /** Its commit; without one, changes are collected from all history. */
+  ref?: string;
+  tag?: string;
+  /** e.g. `v1.4.0 at abc1234, nearest on HEAD`. */
+  reason: string;
+  /**
+   * On a channel, the nearest stable release, when `version` is a channel
+   * version; new versions are bumped from it.
+   */
+  stable?: {
+    version: string;
+    ref?: string;
+    tag?: string;
+  };
+  /**
+   * A release that's been prepared but not released, e.g. by a merged
+   * release pull request: only its `release` steps run.
+   */
+  pending?: Pending;
+}
+/** A prepared release, as a history finds it. */
+interface Pending {
+  version: string;
+  notes?: string;
+  kind?: ReleaseKind;
+  previousVersion?: string;
+  /** e.g. `prepared in #12`. */
+  reason: string;
+}
+/** Defines where previous releases are found, with options as a zod shape. */
+declare function defineHistory<const N extends string, S extends OptionsShape>(definition: FactoryDefinition<N, S, History>): Factory<"history", N, S, History>;
+//#endregion
+//#region src/core/types.d.ts
+/** Every phase, in the order the engine runs its steps. */
+declare const PHASES: readonly ["read-changes", "determine-kind", "determine-notes", "write", "stage", "release"];
+type Phase = (typeof PHASES)[number];
+/**
+ * How much a release changes, whatever the version scheme: the scheme decides
+ * what each kind bumps, e.g. semver's `MAJOR.minor.patch`.
+ */
+declare const KINDS: readonly ["breaking", "feature", "fix", "none"];
+type Kind = (typeof KINDS)[number];
+/** A kind that actually produces a release; `none` releases nothing. */
+type ReleaseKind = Exclude<Kind, "none">;
+/** A single, source-agnostic change (a commit section, an issue, a PR, ...). */
+interface Change {
+  title?: string;
+  description?: string;
+  /** Where this change came from, e.g. `commit aefc3af`. */
+  reason: string;
+  /** Where to read more, e.g. `{ label: "aefc3af", url: ".../commit/aefc3af..." }`. */
+  link?: {
+    label: string;
+    url: string;
+  };
+  /**
+   * How the source categorized it, e.g. a pull request's labels, or the
+   * `### Fixed` section of a changelog.
+   */
+  labels?: string[];
+}
+/**
+ * A versioned unit, as steps see it: one package, a Go module, a Docker
+ * image, or several packages released together under one version.
+ */
+interface ComponentInfo {
+  name: string;
+  /** Its directory, relative to `env.cwd`; `.` for the whole project. */
+  path: string;
+  /** Components it depends on, by name; they're released first. */
+  dependsOn: readonly string[];
+  /**
+   * Pathspecs for git: its directory, without the directories of components
+   * inside it. Empty when every path counts.
+   */
+  pathspec: readonly string[];
+}
+interface ChangesOutput {
+  changes: Change[];
+  /** e.g. `6 changes in 4 commits since 1a2b3c4`. */
+  reason: string;
+}
+interface KindOutput {
+  kind: Kind;
+  /**
+   * Releases exactly this version instead of bumping by the kind, e.g. from
+   * a `Release-As:` footer. It must be valid in the scheme, and later than
+   * the previous version.
+   */
+  version?: string;
+  /** e.g. `'feat!' in title (commit aefc3af)`. */
+  reason: string;
+}
+interface NotesOutput {
+  notes: string;
+  /** e.g. `feature release, 3 features, 1 fix`. */
+  reason: string;
+}
+interface ReleaseOutput {
+  output: unknown;
+  /** Files the step changed (or would change in a dry run), relative to `cwd`. */
+  files?: string[];
+  /** e.g. `wrote 1.3.0 to package.json`. */
+  reason: string;
+}
+/** What `write` and `stage` steps return. */
+interface WriteOutput extends ReleaseOutput {
+  /**
+   * Leaves the release to later, e.g. once a release pull request merges:
+   * every `release` step is skipped with this reason, and the run is
+   * `pending`.
+   */
+  defer?: string;
+}
+/** What the steps of each phase must return. */
+interface StepOutputs {
+  "read-changes": ChangesOutput;
+  "determine-kind": KindOutput;
+  "determine-notes": NotesOutput;
+  write: WriteOutput;
+  stage: WriteOutput;
+  release: ReleaseOutput;
+}
+/** The output of a prior `write`, `stage` or `release` step, as later ones see it. */
+interface ReleaseResult {
+  name: string;
+  output: unknown;
+  files: readonly string[];
+}
+/** Where a component's release starts from; found before any step runs. */
+interface Previous {
+  component: ComponentInfo;
+  /** Absent on a first release, or when the scheme changed since the last one. */
+  previousVersion?: string;
+  /** The commit of the previous release; changes are collected since it. */
+  previousRef?: string;
+  /** The tag of the previous release, when it was found by its tag. */
+  previousTag?: string;
+}
+/** The release being made, from `determine-notes` on. */
+interface Next {
+  kind: ReleaseKind;
+  version: string;
+  /** The release's tag, e.g. `v1.2.0`. */
+  tag: string;
+  /**
+   * Values for `{placeholders}` in templates: `version`, `tag`, `name`, and
+   * the scheme's own, e.g. semver's `major`, `minor` and `patch`.
+   */
+  placeholders: Readonly<Record<string, string>>;
+  /** The components it depends on that are released along with it. */
+  dependencies: readonly Dependency[];
+}
+/** A dependency released along with a component. */
+interface Dependency {
+  name: string;
+  version: string;
+  previousVersion?: string;
+  kind: ReleaseKind;
+}
+/**
+ * What a step receives for one component, by phase. Values from earlier phases
+ * are always present; the value of a step's own phase is only present when
+ * an earlier step of the same phase already ran.
+ */
+interface StepResults {
+  "read-changes": Previous & {
+    changes?: Change[];
+  };
+  "determine-kind": Previous & {
+    changes: Change[];
+    kind?: Kind;
+  };
+  "determine-notes": Previous & Next & {
+    changes: Change[];
+    notes?: string;
+  };
+  write: Previous & Next & {
+    changes: Change[];
+    notes: string;
+    releases: readonly ReleaseResult[];
+  };
+  stage: StepResults["write"];
+  release: StepResults["write"];
+}
+interface Environment {
+  /** Root directory of the project being released. */
+  cwd: string;
+  /** Current branch name. */
+  branch: string;
+  /** When set, steps must not cause side effects. */
+  dryRun: boolean;
+  /** The channel being released on; absent for a stable release. */
+  channel?: RunChannel;
+}
+/**
+ * How a step runs: once per component (`each`, the default), or once with
+ * every component (`all`), e.g. to commit or push their releases together.
+ */
+type Scope = "each" | "all";
+type StepStatus = "ok" | "skipped" | "failed";
+/** What the engine itself records: the previous version, and the next. */
+type EnginePhase = "read-version" | "determine-version";
+/** The audit record of a single step, or of the engine's own work. */
+interface StepRecord {
+  phase: Phase | EnginePhase;
+  name: string;
+  /** The component it ran for; absent for `all` steps. */
+  component?: string;
+  status: StepStatus;
+  durationMs: number;
+  reason: string;
+  output?: unknown;
+  error?: unknown;
+}
+interface Shared<Ctx> {
+  env: Environment;
+  /** User-defined state shared by every step. Never used by bundled steps. */
+  context: Ctx;
+  /** Records of every step that ran before this one. */
+  history: readonly StepRecord[];
+}
+/** What a step receives, for one component. */
+type StepInput<T extends Phase, Ctx = unknown, N extends Fact = never> = Narrow<StepResults[T], N> & Shared<Ctx>;
+/** What an `all` step receives: every component that's still releasing. */
+type AllStepInput<T extends Phase, Ctx = unknown, N extends Fact = never> = {
+  components: readonly Narrow<StepResults[T], N>[];
+} & Shared<Ctx>;
+/** What a step returns, for one component. */
+type StepOutput<T extends Phase, P extends Fact = never> = ProvidedOutput<StepOutputs[T], P>;
+/**
+ * What an `all` step returns: in `write`, `stage` and `release`, one result for all of them;
+ * otherwise a result per component, by name, leaving out those it doesn't
+ * change.
+ */
+type AllStepOutput<T extends Phase, P extends Fact = never> = T extends "release" ? ReleaseOutput : T extends "write" | "stage" ? WriteOutput : {
+  results: Partial<Record<string, StepOutput<T, P>>>;
+  reason: string;
+};
+/**
+ * Whether a step runs, decided just before it would, from what it would
+ * receive. `source` describes it in reports, e.g. the expression it came from.
+ */
+interface StepCondition<I> {
+  (input: I): boolean;
+  readonly source?: string;
+}
+interface StepBase<T extends Phase> {
+  phase: T;
+  name: string;
+  /** Facts the step relies on, e.g. `changes.labels`; checked before anything runs. */
+  needs?: readonly Fact[];
+  /** Facts the step guarantees, e.g. that every change has `labels`; checked on its output. */
+  provides?: readonly Fact[];
+  /** The preset that made the step, with the scheme and history it provides. */
+  preset?: StepPreset;
+}
+/** A preset, as the steps it makes carry it. */
+interface StepPreset {
+  name: string;
+  scheme?: Scheme;
+  history?: History | readonly History[];
+}
+interface EachStepDefinition<T extends Phase, Ctx = unknown> extends StepBase<T> {
+  scope?: "each";
+  /** When set, the step only runs if this returns true; otherwise it's skipped. */
+  if?: StepCondition<StepInput<T, Ctx>>;
+  run: (input: StepInput<T, Ctx>) => StepOutputs[T] | Promise<StepOutputs[T]>;
+}
+interface AllStepDefinition<T extends Phase, Ctx = unknown> extends StepBase<T> {
+  scope: "all";
+  /** When set, the step only runs if this returns true; otherwise it's skipped. */
+  if?: StepCondition<AllStepInput<T, Ctx>>;
+  run: (input: AllStepInput<T, Ctx>) => AllStepOutput<T> | Promise<AllStepOutput<T>>;
+}
+type StepDefinition<T extends Phase, Ctx = unknown> = EachStepDefinition<T, Ctx> | AllStepDefinition<T, Ctx>;
+/** Any step, discriminated by `phase` and `scope`. */
+type Step<Ctx = unknown> = { [T in Phase]: StepDefinition<T, Ctx>; }[Phase];
+//#endregion
+//#region src/core/facts.d.ts
+/**
+ * What can be known about a release before it's made, beyond its shape: what
+ * steps declare they `need`, and what steps and schemes declare they
+ * `provide`. Add your own by declaration merging:
+ *
+ * ```ts
+ * declare module "rylease" {
+ *   interface Facts { "changes.jira": true }
+ * }
+ * ```
+ */
+interface Facts {
+  /** Every change has a `title`. */
+  "changes.title": true;
+  /** Every change has a `description`. */
+  "changes.description": true;
+  /** Every change has `labels`, if only `[]`. */
+  "changes.labels": true;
+  /** Every change has a `link`. */
+  "changes.link": true;
+  /** There's a previous version, in the release's scheme. */
+  previousVersion: true;
+  /** Versions are semantic versions, e.g. as npm requires. */
+  "version.semver": true;
+}
+type Fact = Extract<keyof Facts, string>;
+type ChangeField<N> = N extends `changes.${infer K}` ? Extract<K, keyof Change> : never;
+/** A change that's known to have the given fields. */
+type ChangeWith<K extends keyof Change> = Change & { [P in K]-?: Exclude<Change[P], undefined>; };
+/** A step's input, with what its `needs` guarantee. */
+type Narrow<R, N extends Fact> = [N] extends [never] ? R : Omit<R, ([ChangeField<N>] extends [never] ? never : "changes") | ("previousVersion" extends N ? "previousVersion" : never)> & ([ChangeField<N>] extends [never] ? unknown : {
+  changes: ChangeWith<ChangeField<N>>[];
+}) & ("previousVersion" extends N ? {
+  previousVersion: string;
+} : unknown);
+/** A step's output, with what its `provides` promise. */
+type ProvidedOutput<O, P extends Fact> = [ChangeField<P>] extends [never] ? O : O extends {
+  changes: Change[];
+} ? Omit<O, "changes"> & {
+  changes: ChangeWith<ChangeField<P>>[];
+} : O;
+//#endregion
+//#region src/core/scheme.d.ts
+/**
+ * A version scheme: the one place that knows what a version looks like. It
+ * recognizes and orders versions, works out the next, and names their parts
+ * for templates. Everything else treats versions as plain text.
+ */
+interface Scheme {
+  /** Describes it in reports, e.g. `semver` or `calver YYYY.MM.MICRO`. */
+  readonly name: string;
+  /** Facts that hold for every version it makes, e.g. `version.semver`. */
+  readonly traits?: readonly Fact[];
+  /** Whether a version is one of this scheme's, strictly. */
+  matches(version: string): boolean;
+  /** Orders two of its versions. */
+  compare(a: string, b: string): number;
+  /**
+   * The next version: after `previous` by `kind`, or the first one without
+   * a previous version, e.g. on a first release.
+   */
+  bump(input: BumpInput): {
+    version: string;
+    reason: string;
+  };
+  /** `{placeholders}` for templates, e.g. `{ major: "1", minor: "2", patch: "3" }`. */
+  fields?(version: string): Record<string, string>;
+  /**
+   * How channel versions are written, by channel type, e.g.
+   * `{ prerelease: "{version}rc{n}" }`; by default `{version}-{channel}.{n}`
+   * and `{version}+{channel}.{n}`.
+   */
+  readonly formats?: {
+    readonly prerelease?: string;
+    readonly build?: string;
+  };
+}
+interface BumpInput {
+  /** Absent on a first release, or when the scheme changed since the last one. */
+  previous?: string;
+  kind: ReleaseKind;
+  branch: string;
+  date: Date;
+}
+/**
+ * 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" })`.
+ */
+declare function defineScheme<const N extends string, S extends OptionsShape>(definition: FactoryDefinition<N, S, Scheme>): Factory<"scheme", N, S, Scheme>;
+//#endregion
+//#region src/core/channels.d.ts
+/**
+ * A release channel: versions that wrap the scheme's own in a format with a
+ * counter, e.g. `2.0.0-next.1`. A `prerelease` comes before the version it
+ * leads up to; a `build` comes after the version it numbers builds of.
+ */
+interface Channel {
+  /** Branches that release on this channel, as globs, e.g. `beta/*`. */
+  branches?: readonly string[];
+  /** Defaults to `prerelease`. */
+  type?: ChannelType;
+  /**
+   * How its versions are written: `{version}` is the target version, `{n}`
+   * the counter and `{channel}` the channel's name. Defaults to the
+   * scheme's, or `{version}-{channel}.{n}` for a prerelease and
+   * `{version}+{channel}.{n}` for a build.
+   */
+  format?: string;
+}
+type ChannelType = "prerelease" | "build";
+/** The channel a run releases on. */
+interface RunChannel {
+  name: string;
+  type: ChannelType;
+}
+/** A channel, with its format worked out for a scheme. */
+interface ResolvedChannel extends RunChannel {
+  format: string;
+}
+//#endregion
+//#region src/core/components.d.ts
+/** A versioned unit of the project; see {@link ComponentInfo}. */
+interface Component {
+  name: string;
+  /** Its directory, relative to the project. Defaults to `.`. */
+  path?: string;
+  /** Components it depends on, by name. */
+  dependsOn?: readonly string[];
+  /** Overrides the release's scheme. */
+  scheme?: Scheme;
+  /** Overrides the release's tag template. */
+  tag?: string;
+  /** Overrides where the release finds previous versions. */
+  history?: History;
+}
+/** Finds a project's components, e.g. the packages of a workspace. */
+interface ComponentSource {
+  readonly name: string;
+  resolve(env: Environment): Promise<Component[]>;
+}
+/** Defines a source of components, with options as a zod shape. */
+declare function defineComponents<const N extends string, S extends OptionsShape>(definition: FactoryDefinition<N, S, ComponentSource>): Factory<"components", N, S, ComponentSource>;
+/** A component with everything worked out. */
+interface ResolvedComponent {
+  info: ComponentInfo;
+  scheme: Scheme;
+  history: History;
+  /** The tag template, with `{name}` filled in. */
+  tag: string;
+}
+interface Defaults {
+  scheme: Scheme;
+  history: History;
+  /** Defaults to `v{version}` for one component, `{name}@{version}` for more. */
+  tag: string | undefined;
+}
+/**
+ * Checks components and fills in their defaults, ordered so that each comes
+ * after the components it depends on.
+ */
+declare function resolveComponents(components: readonly Component[], defaults: Defaults): ResolvedComponent[];
+//#endregion
+//#region src/core/reporter.d.ts
+/** Receives progress from the engine; every hook is optional. */
+interface Reporter {
+  start?(env: Environment,
+  /** Every step, and the engine's own rows: `read-version` and `determine-version`. */
+  steps: readonly {
+    phase: Phase | EnginePhase;
+    name: string;
+  }[], components: readonly ComponentInfo[]): void;
+  step?(record: StepRecord): void;
+  finish?(report: ReleaseReport): void;
+}
+interface PrettyReporterOptions {
+  /** Defaults to writing to stdout. */
+  write?: (text: string) => void;
+  /** Defaults to `true` on a TTY unless `NO_COLOR` is set. */
+  color?: boolean;
+}
+/** Aligned, colored output: one row per step with phase, name, duration and reason. */
+declare function prettyReporter(options?: PrettyReporterOptions): Reporter;
+declare function defaultReporter(): Reporter;
+declare function formatDuration(ms: number): string;
+//#endregion
+//#region src/core/engine.d.ts
+interface RunOptions {
+  /** Defaults to `process.cwd()`. */
+  cwd?: string;
+  /** Defaults to the CI's branch (GitHub Actions or GitLab CI), or the checked-out one. */
+  branch?: string;
+  /** Defaults to `false`. */
+  dryRun?: boolean;
+  /** Defaults to pretty output on stdout; pass `null` for silence. */
+  reporter?: Reporter | null;
+  /**
+   * Releases that have already been worked out, e.g. by an earlier job: only
+   * the `release` steps run, for these versions, and every other step is
+   * skipped. With several components, each names its own.
+   */
+  release?: GivenRelease | readonly GivenRelease[];
+  /**
+   * The channel to release on, e.g. `nightly`. Defaults to the first whose
+   * branches match, or a stable release.
+   */
+  channel?: string;
+}
+interface GivenRelease {
+  version: string;
+  /** Defaults to none. */
+  notes?: string;
+  /** Defaults to the version itself. */
+  previousVersion?: string;
+  /** Defaults to the difference between the versions, or `fix`. */
+  kind?: ReleaseKind;
+  /** The component it's for; needed when there are several. */
+  component?: string;
+}
+/** How a release is made: its steps, and how versions are found and made. */
+interface ReleaseSetup<Ctx> {
+  steps: readonly Step<Ctx>[];
+  context: Ctx;
+  scheme: Scheme;
+  /** Defaults to `v{version}` for one component, `{name}@{version}` for several. */
+  tag?: string | undefined;
+  /** Where previous releases are found; the first that finds one wins. */
+  history: History | readonly History[];
+  /** Defaults to one component, the whole project. */
+  components?: readonly Component[] | ComponentSource | undefined;
+  /** Prerelease and build channels, by name. Defaults to none. */
+  channels?: Readonly<Record<string, Channel>> | undefined;
+}
+/**
+ * `pending` when a `write` step left the release to later, e.g. to a
+ * release pull request.
+ */
+type ReleaseStatus = "released" | "pending" | "unchanged" | "failed";
+interface ComponentReport {
+  name: string;
+  path: string;
+  status: ReleaseStatus;
+  previousVersion?: string;
+  previousRef?: string;
+  previousTag?: string;
+  kind?: Kind;
+  version?: string;
+  tag?: string;
+  notes?: string;
+  /** The components it depends on that were released along with it. */
+  dependencies: Dependency[];
+  releases: ReleaseResult[];
+}
+interface ReleaseReport {
+  env: Environment;
+  status: ReleaseStatus;
+  records: StepRecord[];
+  /** Every component, dependencies first. */
+  components: ComponentReport[];
+  /** With one component, its values, for convenience. */
+  previousVersion?: string;
+  previousRef?: string;
+  kind?: Kind;
+  version?: string;
+  notes?: string;
+  /** With one component, the results of its `write`, `stage` and `release` steps. */
+  releases: ReleaseResult[];
+  /** Why the release was left to later, when it's `pending`. */
+  deferred?: string;
+  error?: unknown;
+}
+declare class ReleaseError extends Error {
+  readonly report: ReleaseReport;
+  constructor(message: string, report: ReleaseReport, options?: ErrorOptions);
+}
+/** Stable sort of steps by phase; steps of the same phase keep their order. */
+declare function sortSteps<S extends {
+  phase: Phase;
+}>(steps: readonly S[]): S[];
+declare function runRelease<Ctx>(setup: ReleaseSetup<Ctx>, options?: RunOptions): Promise<ReleaseReport>;
+declare function errorMessage(error: unknown): string;
+//#endregion
+//#region src/core/define.d.ts
+type ReleaseConfig<Context> = {
+  /** Steps to run; they're ordered by phase, keeping their order within a phase. */
+  steps: readonly Step<Context>[];
+  /**
+   * How versions look, are ordered and bumped, e.g. `semver()`. Needed
+   * unless a preset among `steps` provides one, as `conventional` does.
+   */
+  scheme?: Scheme;
+  /**
+   * Each release's tag; `{version}` and `{name}` (the component's) are
+   * filled in. Defaults to `v{version}`, or `{name}@{version}` with several
+   * components.
+   */
+  tag?: string;
+  /**
+   * Where previous releases are found, e.g. `gitTags()`; with several, the
+   * first that finds one wins. Needed unless a preset among `steps`
+   * provides one, as every built-in preset does.
+   */
+  history?: History | readonly History[];
+  /**
+   * What's versioned and released: a list, or a source such as
+   * `npmWorkspaces()`. Defaults to the whole project, as one component.
+   */
+  components?: readonly Component[] | ComponentSource;
+  /**
+   * Prerelease and build channels, by name, e.g.
+   * `{ next: { branches: ["next"] } }` for `2.0.0-next.1`. A run releases
+   * on the first whose branches match, or the one it's given.
+   */
+  channels?: Readonly<Record<string, Channel>>;
+} & (undefined extends Context ? {
+  /** Shared, mutable state passed to every step. */
+  context?: Context;
+} : {
+  /** Shared, mutable state passed to every step. */
+  context: Context;
+});
+interface Release<Context> {
+  readonly steps: readonly Step<Context>[];
+  /** Its own scheme, or its preset's. */
+  readonly scheme: Scheme;
+  /** Its own history, or its preset's. */
+  readonly history: History | readonly History[];
+  run(options?: RunOptions): Promise<ReleaseReport>;
+}
+/**
+ * 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.
+ */
+declare function defineRelease<Context = undefined>(config: ReleaseConfig<Context>): Release<Context>;
+/** The step a factory makes, by scope. */
+type ScopedStep<T extends Phase, Sc extends Scope> = Sc extends "all" ? AllStepDefinition<T> : EachStepDefinition<T>;
+interface StepFactoryDefinition<T extends Phase, N extends string, S extends OptionsShape, Sc extends Scope, Needs extends Fact, Provides extends Fact> {
+  /** Its phase; a function works it out from its options, e.g. a `phase` option. */
+  phase: T | ((options: OptionsValue<S>) => T);
+  /** Identifies the step in reports and in workflow `steps`, e.g. `git/commit`. */
+  name: N;
+  /** One line on what the step does, for generated docs. */
+  description?: string;
+  /** Runs once per component (`each`, the default) or once with all of them (`all`). */
+  scope?: Sc;
+  /**
+   * Facts it relies on, e.g. `changes.labels`; its input is typed
+   * accordingly. A function works them out from its options, e.g. by format.
+   */
+  needs?: readonly Needs[] | ((options: OptionsValue<S>) => readonly Fact[]);
+  /** Facts it guarantees, e.g. that every change has `labels`. */
+  provides?: readonly Provides[];
+  /** A zod shape; use `.default()` for optional options and `.describe()` to document them. */
+  options?: S;
+  run: (input: (Sc extends "all" ? AllStepInput<T, unknown, Needs> : StepInput<T, unknown, Needs>) & {
+    options: OptionsValue<S>;
+  }) => Sc extends "all" ? AllStepOutput<T, Provides> | Promise<AllStepOutput<T, Provides>> : StepOutput<T, Provides> | Promise<StepOutput<T, Provides>>;
+}
+/** Creates a configured step; the options argument is optional when every option is. */
+interface StepFactory<T extends Phase = Phase, N extends string = string, S extends OptionsShape = OptionsShape, Sc extends Scope = Scope> extends Factory<"step", N, S, ScopedStep<T, Sc>> {
+  /** Its phase, or a function of its options that works it out. */
+  readonly phase: T | ((options: OptionsValue<S>) => T);
+  readonly scope: Sc;
+  readonly needs: readonly Fact[];
+  readonly provides: readonly Fact[];
+}
+/** Any step factory, whatever its phase, name or options. */
+interface AnyStepFactory extends AnyFactory<"step", Step> {
+  readonly phase: Phase | ((options: never) => Phase);
+  readonly scope: Scope;
+  readonly needs: readonly Fact[];
+  readonly provides: readonly Fact[];
+}
+/** What a factory accepts, e.g. `FactoryOptions<typeof gitCommit>`. */
+type FactoryOptions<F extends {
+  options: OptionsShape;
+}> = OptionsInput<F["options"]>;
+/**
+ * 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" });
+ * ```
+ */
+declare function defineStep<T extends Phase, const N extends string, S extends OptionsShape = Empty, Sc extends Scope = "each", const Needs extends Fact = never, const Provides extends Fact = never>(definition: StepFactoryDefinition<T, N, S, Sc, Needs, Provides>): StepFactory<T, N, S, Sc>;
+/** Options for each step of a preset, by name; `false` leaves a step out. */
+type PresetOptions<F extends readonly AnyStepFactory[]> = { [K in F[number] as K["name"]]?: FactoryOptions<K> | false; };
+/** A preset's own options for its steps, by name. */
+type PresetDefaults<F extends readonly AnyStepFactory[]> = { [K in F[number] as K["name"]]?: FactoryOptions<K>; };
+/** A named list of step factories that's configured, and used, as one. */
+interface Preset<N extends string = string, F extends readonly AnyStepFactory[] = readonly AnyStepFactory[]> {
+  (options?: PresetOptions<F>): Step[];
+  readonly kind: "preset";
+  readonly name: N;
+  readonly description: string | undefined;
+  readonly steps: F;
+  readonly defaults: PresetDefaults<F>;
+  /** Makes the scheme of releases made with it, unless they set their own. */
+  readonly scheme: (() => Scheme) | undefined;
+  /** Makes the history of releases made with it, unless they set their own. */
+  readonly history: (() => History | readonly History[]) | undefined;
+}
+/**
+ * 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.
+ */
+declare function definePreset<const N extends string, const F extends readonly AnyStepFactory[]>(definition: {
+  name: N;
+  description?: string;
+  steps: F;
+  defaults?: PresetDefaults<F>;
+  scheme?: () => Scheme;
+  history?: () => History | readonly History[];
+}): Preset<N, F>;
+/** What a step's condition receives. */
+type ConditionInput<S> = S extends {
+  run: (input: infer I) => unknown;
+} ? I : never;
+/**
+ * Makes a step run only when `condition` holds, on top of any condition it
+ * already has: `when(steps.npmPublish(), ({ env }) => !env.dryRun)`.
+ */
+declare function when<S extends Step<never>>(step: S, condition: StepCondition<ConditionInput<S>>): S;
+//#endregion
+//#region src/config/workflow.d.ts
+/** What a workflow gives, already parsed from YAML. */
+interface WorkflowInput {
+  steps: unknown;
+  scheme?: unknown;
+  tag?: unknown;
+  history?: unknown;
+  components?: unknown;
+  channels?: unknown;
+}
+/** A release defined in a workflow, ready for `defineRelease`. */
+type WorkflowRelease = Omit<ReleaseConfig<undefined>, "context">;
+/**
+ * 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
+ * ```
+ */
+declare function resolveWorkflow(input: WorkflowInput, options: WorkflowOptions): Promise<WorkflowRelease>;
+interface WorkflowOptions {
+  /** Paths and packages are resolved from here. */
+  cwd: string;
+}
+/**
+ * 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
+ * ```
+ */
+declare function resolveWorkflowSteps(entries: unknown, options: WorkflowOptions): Promise<Step[]>;
+//#endregion
+//#region src/core/expression.d.ts
+/**
+ * What an `if:` expression can read: the release so far, as the step itself
+ * would receive it.
+ */
+interface ExpressionContext {
+  dryRun: boolean;
+  branch: string;
+  cwd: string;
+  /** The channel being released on, or `null` for a stable release. */
+  channel: string | null;
+  /** Whether the release is on a prerelease channel. */
+  prerelease: boolean;
+  /** The component the step runs for: `{ name, path }`; absent for `all` steps. */
+  component?: {
+    name: string;
+    path: string;
+  };
+  /** For `all` steps: every component being released, with its values. */
+  components?: readonly unknown[];
+  previousVersion?: string;
+  previousRef?: string;
+  previousTag?: string;
+  changes?: readonly unknown[];
+  kind?: string;
+  version?: string;
+  tag?: string;
+  notes?: string;
+  /** The components it depends on released along with it: `{ name, version, … }`. */
+  dependencies?: readonly unknown[];
+  /** The steps that ran before, by name: `{ phase, status, reason, output }`. */
+  steps: Record<string, unknown>;
+}
+/** What an expression reads, from what a step receives: for one component, or all. */
+declare function expressionContext(input: unknown): ExpressionContext;
+type Node = (context: ExpressionContext) => unknown;
+/**
+ * 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`.
+ */
+declare function compileExpression(source: string): Node;
+//#endregion
+//#region src/core/summary.d.ts
+/**
+ * The report as Markdown, for GitHub's job summary: what happened, a row per
+ * step, and the release notes.
+ */
+declare function markdownSummary(report: ReleaseReport): string;
+//#endregion
+//#region src/histories/fs/version-file.d.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.
+ */
+declare const fsVersionFile: Factory<"history", "fs/version-file", {
+  format: z.ZodDefault<z.ZodEnum<{
+    cargo: "cargo";
+    dart: "dart";
+    dotnet: "dotnet";
+    gradle: "gradle";
+    helm: "helm";
+    maven: "maven";
+    npm: "npm";
+    pattern: "pattern";
+    plain: "plain";
+    python: "python";
+    ruby: "ruby";
+  }>>;
+  path: z.ZodOptional<z.ZodString>;
+  pattern: z.ZodOptional<z.ZodString>;
+}, History>;
+//#endregion
+//#region src/histories/git/git-tags.d.ts
+/**
+ * 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.
+ */
+declare const gitTags: Factory<"history", "git/tags", Readonly<{
+  [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>, History>;
+//#endregion
+//#region src/histories/github/release-pr.d.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`.
+ */
+declare const githubReleasePr: Factory<"history", "github/release-pr", {
+  label: z.ZodDefault<z.ZodString>;
+  repo: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, History>;
+declare namespace index_d_exports$3 {
+  export { fsVersionFile, gitTags, githubReleasePr };
+}
+//#endregion
+//#region src/presets/change-files.d.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`.
+ */
+declare const changeFiles: Preset<"change-files", readonly [StepFactory<"read-changes", "change-files/read", {
+  directory: import("zod").ZodDefault<import("zod").ZodString>;
+}, "all">, StepFactory<"determine-kind", "labels/determine-kind", {
+  kinds: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: import("zod").ZodDefault<import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">, StepFactory<"determine-notes", "labels/determine-notes", {
+  sections: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+    title: import("zod").ZodString;
+    labels: import("zod").ZodArray<import("zod").ZodString>;
+  }, import("zod/v4/core").$strict>>>;
+  other: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  exclude: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  descriptions: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  links: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  dependencies: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "each">, StepFactory<"write", "change-files/clean", {
+  directory: import("zod").ZodDefault<import("zod").ZodString>;
+  channels: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "all">, StepFactory<"write", "fs/write-changes", {
+  path: import("zod").ZodDefault<import("zod").ZodString>;
+  heading: import("zod").ZodDefault<import("zod").ZodString>;
+  mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+    append: "append";
+    prepend: "prepend";
+    replace: "replace";
+  }>>;
+  channels: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "each">, StepFactory<"stage", "git/commit", {
+  files: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "git/create-tag", {
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  move: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "github/create-release", {
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  draft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  prerelease: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodLiteral<"auto">]>>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "each">]>;
+//#endregion
+//#region src/presets/conventional.d.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`.
+ */
+declare const conventional: Preset<"conventional", readonly [StepFactory<"read-changes", "conventional/read-commits", Empty, "each">, StepFactory<"determine-kind", "conventional/determine-kind", {
+  types: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: import("zod").ZodDefault<import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">, StepFactory<"determine-notes", "conventional/determine-notes", {
+  sections: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+    title: import("zod").ZodString;
+    types: import("zod").ZodArray<import("zod").ZodString>;
+  }, import("zod/v4/core").$strict>>>;
+  breaking: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  other: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  links: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  dependencies: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "each">, StepFactory<"release", "git/create-tag", {
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  move: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "github/create-release", {
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  draft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  prerelease: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodLiteral<"auto">]>>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "each">]>;
+//#endregion
+//#region src/presets/conventional-pr.d.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.
+ */
+declare const conventionalPr: Preset<"conventional-pr", readonly [StepFactory<"read-changes", "conventional/read-commits", Empty, "each">, StepFactory<"determine-kind", "conventional/determine-kind", {
+  types: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: import("zod").ZodDefault<import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">, StepFactory<"determine-notes", "conventional/determine-notes", {
+  sections: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+    title: import("zod").ZodString;
+    types: import("zod").ZodArray<import("zod").ZodString>;
+  }, import("zod/v4/core").$strict>>>;
+  breaking: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  other: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  links: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  dependencies: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "each">, StepFactory<"write", "fs/write-changes", {
+  path: import("zod").ZodDefault<import("zod").ZodString>;
+  heading: import("zod").ZodDefault<import("zod").ZodString>;
+  mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+    append: "append";
+    prepend: "prepend";
+    replace: "replace";
+  }>>;
+  channels: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "each">, StepFactory<"stage", "github/open-release-pr", {
+  branch: import("zod").ZodDefault<import("zod").ZodString>;
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  labels: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  remote: import("zod").ZodDefault<import("zod").ZodString>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "all">, StepFactory<"release", "git/create-tag", {
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  move: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "github/create-release", {
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  draft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  prerelease: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodLiteral<"auto">]>>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "each">]>;
+//#endregion
+//#region src/presets/keep-a-changelog.d.ts
+/**
+ * `## [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.
+ */
+declare const keepAChangelog: Preset<"keep-a-changelog", readonly [StepFactory<"read-changes", "keep-a-changelog/read-unreleased", {
+  path: import("zod").ZodDefault<import("zod").ZodString>;
+}, "each">, StepFactory<"determine-kind", "labels/determine-kind", {
+  kinds: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: import("zod").ZodDefault<import("zod").ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">, StepFactory<"determine-notes", "labels/determine-notes", {
+  sections: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+    title: import("zod").ZodString;
+    labels: import("zod").ZodArray<import("zod").ZodString>;
+  }, import("zod/v4/core").$strict>>>;
+  other: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+  exclude: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  descriptions: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  links: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  dependencies: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "each">, StepFactory<"write", "keep-a-changelog/write-release", {
+  path: import("zod").ZodDefault<import("zod").ZodString>;
+  heading: import("zod").ZodDefault<import("zod").ZodString>;
+  channels: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "each">, StepFactory<"stage", "git/commit", {
+  files: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "git/create-tag", {
+  message: import("zod").ZodDefault<import("zod").ZodString>;
+  move: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+  push: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<false>]>>;
+}, "all">, StepFactory<"release", "github/create-release", {
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  draft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  prerelease: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodLiteral<"auto">]>>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "each">]>;
+declare namespace index_d_exports$2 {
+  export { changeFiles, conventional, conventionalPr, keepAChangelog };
+}
+//#endregion
+//#region src/schemes/calver.d.ts
+/**
+ * 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.
+ */
+declare const calver: Factory<"scheme", "calver", {
+  format: z.ZodDefault<z.ZodString>;
+  timezone: z.ZodDefault<z.ZodString>;
+}, Scheme>;
+//#endregion
+//#region src/schemes/semver.d.ts
+/** A strict semantic version. */
+interface Semver {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease?: string;
+  build?: string;
+}
+/** Whether a version is valid semver: `MAJOR.MINOR.PATCH`, without leading zeros. */
+declare function isSemver(version: string): boolean;
+declare function parseSemver(version: string): Semver;
+declare function formatSemver(version: Semver): string;
+/** Bumps a version: `breaking` → major, `feature` → minor, `fix` → patch. */
+declare function bumpSemver(version: Semver, kind: ReleaseKind): Semver;
+/**
+ * `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`).
+ */
+declare const semver: Factory<"scheme", "semver", {
+  shiftPreMajor: z.ZodDefault<z.ZodBoolean>;
+  initial: z.ZodDefault<z.ZodString>;
+}, Scheme>;
+declare namespace index_d_exports$1 {
+  export { Semver, bumpSemver, calver, formatSemver, isSemver, parseSemver, semver };
+}
+//#endregion
+//#region src/steps/cargo/publish.d.ts
+/**
+ * Publishes the crate to crates.io, or another registry, after earlier steps
+ * wrote the new version to `Cargo.toml`. Cargo verifies the crate builds
+ * first, and waits for it to be available, so dependents publish after it.
+ */
+declare const cargoPublish: StepFactory<"release", "cargo/publish", {
+  path: z.ZodDefault<z.ZodString>;
+  registry: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/change-files/clean.d.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.
+ */
+declare const changeFilesClean: StepFactory<"write", "change-files/clean", {
+  directory: import("zod").ZodDefault<import("zod").ZodString>;
+  channels: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "all">;
+//#endregion
+//#region src/steps/change-files/read.d.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`.
+ */
+declare const changeFilesRead: StepFactory<"read-changes", "change-files/read", {
+  directory: import("zod").ZodDefault<import("zod").ZodString>;
+}, "all">;
+//#endregion
+//#region src/steps/components/dependents.d.ts
+/**
+ * Releases the components that depend on a released component, so their
+ * releases pick up the new version, e.g. with `fs/write-version` updating
+ * their dependency on it. Dependents of dependents follow.
+ */
+declare const componentsDependents: StepFactory<"determine-kind", "components/dependents", {
+  kind: z.ZodDefault<z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+  }>>;
+  on: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+  }>>>;
+}, "all">;
+//#endregion
+//#region src/steps/conventional/determine-kind.d.ts
+/**
+ * `!` or `BREAKING` → breaking; otherwise each change's kind comes from its
+ * conventional type, and the highest kind wins.
+ */
+declare const conventionalDetermineKind: StepFactory<"determine-kind", "conventional/determine-kind", {
+  types: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: z.ZodDefault<z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">;
+//#endregion
+//#region src/steps/conventional/determine-notes.d.ts
+/**
+ * A `### Title` section for breaking changes, then one per group of
+ * conventional types, then the rest.
+ */
+declare const conventionalBuildNotes: StepFactory<"determine-notes", "conventional/determine-notes", {
+  sections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    types: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>>>;
+  breaking: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+  other: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+  links: z.ZodDefault<z.ZodBoolean>;
+  dependencies: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+}, "each">;
+//#endregion
+//#region src/steps/conventional/read-commits.d.ts
+/**
+ * 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.
+ */
+declare const conventionalReadCommits: StepFactory<"read-changes", "conventional/read-commits", Empty, "each">;
+//#endregion
+//#region src/steps/dart/publish.d.ts
+/**
+ * Publishes the package to pub.dev, or the server in its `publish_to`, after
+ * earlier steps wrote the new version to `pubspec.yaml`.
+ */
+declare const dartPublish: StepFactory<"release", "dart/publish", {
+  path: z.ZodDefault<z.ZodString>;
+  client: z.ZodOptional<z.ZodEnum<{
+    dart: "dart";
+    flutter: "flutter";
+  }>>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/dotnet/publish.d.ts
+/**
+ * Pushes the component's packed NuGet packages to nuget.org, or another
+ * source: pack them first, e.g. with `dotnet pack -c Release`. Only the
+ * packages of the version being released are pushed, their symbols with them.
+ */
+declare const dotnetPublish: StepFactory<"release", "dotnet/publish", {
+  files: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  allowNoMatch: z.ZodDefault<z.ZodBoolean>;
+  source: z.ZodDefault<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/exec/command.d.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}`.
+ */
+declare const execCommand: StepFactory<"release" | "stage" | "write", "exec/command", {
+  phase: z.ZodEnum<{
+    release: "release";
+    stage: "stage";
+    write: "write";
+  }>;
+  command: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+  dryRun: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  cwd: z.ZodDefault<z.ZodString>;
+  env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+  files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, "each">;
+//#endregion
+//#region src/steps/fs/write-changes.d.ts
+/** Writes release notes to a file, creating it if needed. */
+declare const fsWriteChanges: StepFactory<"write", "fs/write-changes", {
+  path: z.ZodDefault<z.ZodString>;
+  heading: z.ZodDefault<z.ZodString>;
+  mode: z.ZodDefault<z.ZodEnum<{
+    append: "append";
+    prepend: "prepend";
+    replace: "replace";
+  }>>;
+  channels: z.ZodDefault<z.ZodBoolean>;
+}, "each">;
+//#endregion
+//#region src/steps/fs/write-version.d.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`, `cargo` and
+ * `dart` formats, dependencies on the other components released with it are
+ * pointed at their new versions too, keeping each range's operator.
+ */
+declare const fsWriteVersion: StepFactory<"write", "fs/write-version", {
+  format: z.ZodDefault<z.ZodEnum<{
+    cargo: "cargo";
+    dart: "dart";
+    dotnet: "dotnet";
+    gradle: "gradle";
+    helm: "helm";
+    maven: "maven";
+    npm: "npm";
+    pattern: "pattern";
+    plain: "plain";
+    python: "python";
+    ruby: "ruby";
+  }>>;
+  path: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  allowNoMatch: z.ZodDefault<z.ZodBoolean>;
+  pattern: z.ZodOptional<z.ZodString>;
+}, "all">;
+//#endregion
+//#region src/steps/git/commit.d.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.
+ */
+declare const gitCommit: StepFactory<"stage", "git/commit", {
+  files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  message: z.ZodDefault<z.ZodString>;
+  push: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+}, "all">;
+//#endregion
+//#region src/steps/git/create-tag.d.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.
+ */
+declare const gitCreateTag: StepFactory<"release", "git/create-tag", {
+  message: z.ZodDefault<z.ZodString>;
+  move: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  push: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+}, "all">;
+//#endregion
+//#region src/steps/github/create-release.d.ts
+/**
+ * Creates a GitHub release for the version, with the notes as its body, or
+ * finds the one another job already created.
+ */
+declare const githubCreateRelease: StepFactory<"release", "github/create-release", {
+  title: import("zod").ZodDefault<import("zod").ZodString>;
+  draft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+  prerelease: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodLiteral<"auto">]>>;
+  repo: import("zod").ZodOptional<import("zod").ZodString>;
+  token: import("zod").ZodOptional<import("zod").ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/github/open-release-pr.d.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.
+ */
+declare const githubOpenReleasePr: StepFactory<"stage", "github/open-release-pr", {
+  branch: z.ZodDefault<z.ZodString>;
+  title: z.ZodDefault<z.ZodString>;
+  labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  remote: z.ZodDefault<z.ZodString>;
+  repo: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "all">;
+//#endregion
+//#region src/steps/github/read-pull-requests.d.ts
+/**
+ * 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.
+ */
+declare const githubReadPullRequests: StepFactory<"read-changes", "github/read-pull-requests", {
+  repo: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/github/upload-artifact.d.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.
+ */
+declare const githubUploadArtifact: StepFactory<"release", "github/upload-artifact", {
+  name: z.ZodString;
+  files: z.ZodArray<z.ZodString>;
+  allowNoMatch: z.ZodDefault<z.ZodBoolean>;
+  dryRunArtifact: z.ZodDefault<z.ZodBoolean>;
+  retentionDays: z.ZodOptional<z.ZodNumber>;
+}, "each">;
+//#endregion
+//#region src/steps/github/upload-release-assets.d.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.
+ */
+declare const githubUploadReleaseAssets: StepFactory<"release", "github/upload-release-assets", {
+  title: z.ZodDefault<z.ZodString>;
+  draft: z.ZodDefault<z.ZodBoolean>;
+  prerelease: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+  repo: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+  files: z.ZodArray<z.ZodString>;
+  allowNoMatch: z.ZodDefault<z.ZodBoolean>;
+  clobber: z.ZodDefault<z.ZodBoolean>;
+  dryRunArtifact: z.ZodDefault<z.ZodBoolean>;
+  artifactName: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/gitlab/create-release.d.ts
+/**
+ * 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.
+ */
+declare const gitlabCreateRelease: StepFactory<"release", "gitlab/create-release", {
+  title: z.ZodDefault<z.ZodString>;
+  project: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/keep-a-changelog/read-unreleased.d.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.
+ */
+declare const keepAChangelogReadUnreleased: StepFactory<"read-changes", "keep-a-changelog/read-unreleased", {
+  path: z.ZodDefault<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/keep-a-changelog/write-release.d.ts
+/**
+ * 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.
+ */
+declare const keepAChangelogWriteRelease: StepFactory<"write", "keep-a-changelog/write-release", {
+  path: z.ZodDefault<z.ZodString>;
+  heading: z.ZodDefault<z.ZodString>;
+  channels: z.ZodDefault<z.ZodBoolean>;
+}, "each">;
+//#endregion
+//#region src/steps/labels/determine-kind.d.ts
+/**
+ * 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.
+ */
+declare const labelsDetermineKind: StepFactory<"determine-kind", "labels/determine-kind", {
+  kinds: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>>;
+  fallback: z.ZodDefault<z.ZodEnum<{
+    breaking: "breaking";
+    feature: "feature";
+    fix: "fix";
+    none: "none";
+  }>>;
+}, "each">;
+//#endregion
+//#region src/steps/labels/determine-notes.d.ts
+/**
+ * A `### Title` section per group of labels, like GitHub's own release notes
+ * categories, then the rest.
+ */
+declare const labelsBuildNotes: StepFactory<"determine-notes", "labels/determine-notes", {
+  sections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    labels: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>>>;
+  other: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+  exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  descriptions: z.ZodDefault<z.ZodBoolean>;
+  links: z.ZodDefault<z.ZodBoolean>;
+  dependencies: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+}, "each">;
+//#endregion
+//#region src/steps/npm/publish.d.ts
+/**
+ * Publishes the package to npm, after earlier steps wrote the new version to
+ * `package.json`. Lifecycle scripts like `prepublishOnly` run as usual.
+ */
+declare const npmPublish: StepFactory<"release", "npm/publish", {
+  path: z.ZodDefault<z.ZodString>;
+  client: z.ZodOptional<z.ZodEnum<{
+    npm: "npm";
+    pnpm: "pnpm";
+  }>>;
+  tag: z.ZodOptional<z.ZodString>;
+  access: z.ZodOptional<z.ZodEnum<{
+    public: "public";
+    restricted: "restricted";
+  }>>;
+  provenance: z.ZodDefault<z.ZodBoolean>;
+  registry: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/python/publish.d.ts
+/**
+ * Uploads the component's built distributions to PyPI, or another index:
+ * build them first, e.g. with `uv build`. Only the files of the version
+ * being released are uploaded.
+ */
+declare const pythonPublish: StepFactory<"release", "python/publish", {
+  files: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  allowNoMatch: z.ZodDefault<z.ZodBoolean>;
+  client: z.ZodDefault<z.ZodEnum<{
+    twine: "twine";
+    uv: "uv";
+  }>>;
+  registry: z.ZodDefault<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+//#endregion
+//#region src/steps/ruby/publish.d.ts
+/**
+ * Packs the component's gem from its gemspec and pushes it to RubyGems, or
+ * another host, after earlier steps wrote the new version to it.
+ */
+declare const rubyPublish: StepFactory<"release", "ruby/publish", {
+  gemspec: z.ZodOptional<z.ZodString>;
+  host: z.ZodDefault<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+}, "each">;
+declare namespace index_d_exports {
+  export { cargoPublish, changeFilesClean, changeFilesRead, componentsDependents, conventionalBuildNotes, conventionalDetermineKind, conventionalReadCommits, dartPublish, dotnetPublish, execCommand, fsWriteChanges, fsWriteVersion, gitCommit, gitCreateTag, githubCreateRelease, githubOpenReleasePr, githubReadPullRequests, githubUploadArtifact, githubUploadReleaseAssets, gitlabCreateRelease, keepAChangelogReadUnreleased, keepAChangelogWriteRelease, labelsBuildNotes, labelsDetermineKind, npmPublish, pythonPublish, rubyPublish };
+}
+//#endregion
+//#region src/utils/git.d.ts
+/** Runs `git` in `cwd` and resolves with its trimmed stdout. */
+declare function git(cwd: string, ...args: string[]): Promise<string>;
+/** Like {@link git}, but resolves with `undefined` instead of rejecting. */
+declare function tryGit(cwd: string, ...args: string[]): Promise<string | undefined>;
+/** `GITHUB_REPOSITORY`, or `owner/repo` from the `origin` remote. */
+declare function detectRepo(cwd: string): Promise<string | undefined>;
+//#endregion
+export { Channel as $, OptionsShape as $t, defineStep as A, Step as At, runRelease as B, WriteOutput as Bt, Release as C, PHASES as Ct, StepFactoryDefinition as D, ReleaseOutput as Dt, StepFactory as E, ReleaseKind as Et, ReleaseReport as F, StepOutputs as Ft, formatDuration as G, defineHistory as Gt, PrettyReporterOptions as H, History as Ht, ReleaseSetup as I, StepPreset as It, ComponentSource as J, FactoryKind as Jt, prettyReporter as K, AnyFactory as Kt, ReleaseStatus as L, StepRecord as Lt, ComponentReport as M, StepDefinition as Mt, GivenRelease as N, StepInput as Nt, definePreset as O, ReleaseResult as Ot, ReleaseError as P, StepOutput as Pt, resolveComponents as Q, OptionsInput as Qt, RunOptions as R, StepResults as Rt, PresetOptions as S, NotesOutput as St, ScopedStep as T, Previous as Tt, Reporter as U, HistoryInput as Ut, sortSteps as V, Found as Vt, defaultReporter as W, Pending as Wt, ResolvedComponent as X, Empty as Xt, Defaults as Y, index_d_exports$4 as Yt, defineComponents as Z, OptionsError as Zt, AnyStepFactory as _, Environment as _t, index_d_exports$1 as a, ChangeWith as at, Preset as b, KindOutput as bt, markdownSummary as c, AllStepDefinition as ct, expressionContext as d, Change as dt, OptionsValue as en, ChannelType as et, WorkflowInput as f, ChangesOutput as ft, resolveWorkflowSteps as g, EnginePhase as gt, resolveWorkflow as h, EachStepDefinition as ht, index_d_exports as i, defineScheme as it, when as j, StepCondition as jt, defineRelease as k, Scope as kt, ExpressionContext as l, AllStepInput as lt, WorkflowRelease as m, Dependency as mt, git as n, parseOptions as nn, BumpInput as nt, index_d_exports$2 as o, Fact as ot, WorkflowOptions as p, ComponentInfo as pt, Component as q, Factory as qt, tryGit as r, z as rn, Scheme as rt, index_d_exports$3 as s, Facts as st, detectRepo as t, joinPath as tn, RunChannel as tt, compileExpression as u, AllStepOutput as ut, ConditionInput as v, KINDS as vt, ReleaseConfig as w, Phase as wt, PresetDefaults as x, Next as xt, FactoryOptions as y, Kind as yt, errorMessage as z, StepStatus as zt };
+//# sourceMappingURL=index-CDKUm2-t.d.mts.map