rylease 3.0.0 → 3.1.0

package/dist/index.d.mts

@@ -1,1571 +1,2 @@
-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`. */
-export type OptionsShape = core.$ZodShape;
-/** What a step accepts: options with a default may be left out. */
-export type OptionsInput<S extends OptionsShape> = core.$InferObjectInput<S, Empty>;
-/** What a step's `run` receives: every default applied. */
-export type OptionsValue<S extends OptionsShape> = core.$InferObjectOutput<S, Empty>;
-/** An object type with no properties. */
-export type Empty = Record<never, never>;
-/** Options that don't match a step's schema; the message lists every problem. */
-export 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: ...`.
- */
-export declare function parseOptions<S extends OptionsShape>(shape: S, value: unknown, path: string): OptionsValue<S>;
-export declare function joinPath(path: string, keys?: readonly PropertyKey[]): string;
-//#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 {
-  export { 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, ... */
-export 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>;
-}
-export 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. */
-export 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. */
-export 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. */
-export 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. */
-export declare const PHASES: readonly ["read-changes", "determine-kind", "determine-notes", "write", "stage", "release"];
-export 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`.
- */
-export declare const KINDS: readonly ["breaking", "feature", "fix", "none"];
-export type Kind = (typeof KINDS)[number];
-/** A kind that actually produces a release; `none` releases nothing. */
-export type ReleaseKind = Exclude<Kind, "none">;
-/** A single, source-agnostic change (a commit section, an issue, a PR, ...). */
-export 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.
- */
-export 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[];
-}
-export interface ChangesOutput {
-  changes: Change[];
-  /** e.g. `6 changes in 4 commits since 1a2b3c4`. */
-  reason: string;
-}
-export 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;
-}
-export interface NotesOutput {
-  notes: string;
-  /** e.g. `feature release, 3 features, 1 fix`. */
-  reason: string;
-}
-export 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. */
-export 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. */
-export 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. */
-export interface ReleaseResult {
-  name: string;
-  output: unknown;
-  files: readonly string[];
-}
-/** Where a component's release starts from; found before any step runs. */
-export 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. */
-export 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. */
-export 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.
- */
-export 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"];
-}
-export 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.
- */
-export type Scope = "each" | "all";
-export type StepStatus = "ok" | "skipped" | "failed";
-/** What the engine itself records: the previous version, and the next. */
-export type EnginePhase = "read-version" | "determine-version";
-/** The audit record of a single step, or of the engine's own work. */
-export 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. */
-export 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. */
-export 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. */
-export 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.
- */
-export 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.
- */
-export 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. */
-export interface StepPreset {
-  name: string;
-  scheme?: Scheme;
-  history?: History | readonly History[];
-}
-export 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]>;
-}
-export 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>>;
-}
-export type StepDefinition<T extends Phase, Ctx = unknown> = EachStepDefinition<T, Ctx> | AllStepDefinition<T, Ctx>;
-/** Any step, discriminated by `phase` and `scope`. */
-export 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.
- */
-export 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;
-  };
-}
-export 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" })`.
- */
-export 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}. */
-export 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. */
-export interface ComponentSource {
-  readonly name: string;
-  resolve(env: Environment): Promise<Component[]>;
-}
-/** Defines a source of components, with options as a zod shape. */
-export 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. */
-export interface ResolvedComponent {
-  info: ComponentInfo;
-  scheme: Scheme;
-  history: History;
-  /** The tag template, with `{name}` filled in. */
-  tag: string;
-}
-export 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.
- */
-export 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. */
-export 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;
-}
-export 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. */
-export declare function prettyReporter(options?: PrettyReporterOptions): Reporter;
-export declare function defaultReporter(): Reporter;
-export declare function formatDuration(ms: number): string;
-//#endregion
-//#region src/core/engine.d.ts
-export 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;
-}
-export 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. */
-export 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.
- */
-export type ReleaseStatus = "released" | "pending" | "unchanged" | "failed";
-export 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[];
-}
-export 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;
-}
-export 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. */
-export declare function sortSteps<S extends {
-  phase: Phase;
-}>(steps: readonly S[]): S[];
-export declare function runRelease<Ctx>(setup: ReleaseSetup<Ctx>, options?: RunOptions): Promise<ReleaseReport>;
-export declare function errorMessage(error: unknown): string;
-//#endregion
-//#region src/core/define.d.ts
-export 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;
-});
-export 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.
- */
-export declare function defineRelease<Context = undefined>(config: ReleaseConfig<Context>): Release<Context>;
-/** The step a factory makes, by scope. */
-export type ScopedStep<T extends Phase, Sc extends Scope> = Sc extends "all" ? AllStepDefinition<T> : EachStepDefinition<T>;
-export 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. */
-export 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. */
-export 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>`. */
-export 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" });
- * ```
- */
-export 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. */
-export 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. */
-export 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. */
-export 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.
- */
-export 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. */
-export 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)`.
- */
-export 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. */
-export interface WorkflowInput {
-  steps: unknown;
-  scheme?: unknown;
-  tag?: unknown;
-  history?: unknown;
-  components?: unknown;
-  channels?: unknown;
-}
-/** A release defined in a workflow, ready for `defineRelease`. */
-export 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
- * ```
- */
-export declare function resolveWorkflow(input: WorkflowInput, options: WorkflowOptions): Promise<WorkflowRelease>;
-export 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
- * ```
- */
-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. */
-export 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`.
- */
-export 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.
- */
-export 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";
-    gradle: "gradle";
-    helm: "helm";
-    maven: "maven";
-    npm: "npm";
-    pattern: "pattern";
-    plain: "plain";
-    python: "python";
-  }>>;
-  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$1 {
-  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$3 {
-  export { Semver, bumpSemver, calver, formatSemver, isSemver, parseSemver, semver };
-}
-//#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 `npm/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/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` and `cargo`
- * 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";
-    gradle: "gradle";
-    helm: "helm";
-    maven: "maven";
-    npm: "npm";
-    pattern: "pattern";
-    plain: "plain";
-    python: "python";
-  }>>;
-  path: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-  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>;
-  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>;
-  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">;
-declare namespace index_d_exports$4 {
-  export { changeFilesClean, changeFilesRead, componentsDependents, conventionalBuildNotes, conventionalDetermineKind, conventionalReadCommits, execCommand, fsWriteChanges, fsWriteVersion, gitCommit, gitCreateTag, githubCreateRelease, githubOpenReleasePr, githubReadPullRequests, githubUploadArtifact, githubUploadReleaseAssets, gitlabCreateRelease, keepAChangelogReadUnreleased, keepAChangelogWriteRelease, labelsBuildNotes, labelsDetermineKind, npmPublish };
-}
-//#endregion
-//#region src/utils/git.d.ts
-/** Runs `git` in `cwd` and resolves with its trimmed stdout. */
-export declare function git(cwd: string, ...args: string[]): Promise<string>;
-/** Like {@link git}, but resolves with `undefined` instead of rejecting. */
-export declare function tryGit(cwd: string, ...args: string[]): Promise<string | undefined>;
-//#endregion
-export { type AnyFactory, type ChangeWith, type Channel, type ChannelType, type ExpressionContext, type Fact, type Factory, type FactoryKind, type Facts, type RunChannel, index_d_exports as components, index_d_exports$1 as histories, index_d_exports$2 as presets, index_d_exports$3 as schemes, index_d_exports$4 as steps, z };
-//# sourceMappingURL=index.d.mts.map
+import { $ as Channel, $t as OptionsShape, A as defineStep, At as Step, B as runRelease, Bt as WriteOutput, C as Release, Ct as PHASES, D as StepFactoryDefinition, Dt as ReleaseOutput, E as StepFactory, Et as ReleaseKind, F as ReleaseReport, Ft as StepOutputs, G as formatDuration, Gt as defineHistory, H as PrettyReporterOptions, Ht as History, I as ReleaseSetup, It as StepPreset, J as ComponentSource, Jt as FactoryKind, K as prettyReporter, Kt as AnyFactory, L as ReleaseStatus, Lt as StepRecord, M as ComponentReport, Mt as StepDefinition, N as GivenRelease, Nt as StepInput, O as definePreset, Ot as ReleaseResult, P as ReleaseError, Pt as StepOutput, Q as resolveComponents, Qt as OptionsInput, R as RunOptions, Rt as StepResults, S as PresetOptions, St as NotesOutput, T as ScopedStep, Tt as Previous, U as Reporter, Ut as HistoryInput, V as sortSteps, Vt as Found, W as defaultReporter, Wt as Pending, X as ResolvedComponent, Xt as Empty, Y as Defaults, Yt as index_d_exports, Z as defineComponents, Zt as OptionsError, _ as AnyStepFactory, _t as Environment, a as index_d_exports$3, at as ChangeWith, b as Preset, bt as KindOutput, c as markdownSummary, ct as AllStepDefinition, d as expressionContext, dt as Change, en as OptionsValue, et as ChannelType, f as WorkflowInput, ft as ChangesOutput, g as resolveWorkflowSteps, gt as EnginePhase, h as resolveWorkflow, ht as EachStepDefinition, i as index_d_exports$4, it as defineScheme, j as when, jt as StepCondition, k as defineRelease, kt as Scope, l as ExpressionContext, lt as AllStepInput, m as WorkflowRelease, mt as Dependency, n as git, nn as parseOptions, nt as BumpInput, o as index_d_exports$2, ot as Fact, p as WorkflowOptions, pt as ComponentInfo, q as Component, qt as Factory, r as tryGit, rn as z, rt as Scheme, s as index_d_exports$1, st as Facts, tn as joinPath, tt as RunChannel, u as compileExpression, ut as AllStepOutput, v as ConditionInput, vt as KINDS, w as ReleaseConfig, wt as Phase, x as PresetDefaults, xt as Next, y as FactoryOptions, yt as Kind, z as errorMessage, zt as StepStatus } from "./index-qxjyrLIy.mjs";
+export { AllStepDefinition, AllStepInput, AllStepOutput, type AnyFactory, AnyStepFactory, BumpInput, Change, type ChangeWith, ChangesOutput, type Channel, type ChannelType, Component, ComponentInfo, ComponentReport, ComponentSource, ConditionInput, Defaults, Dependency, EachStepDefinition, Empty, EnginePhase, Environment, type ExpressionContext, type Fact, type Factory, type FactoryKind, FactoryOptions, type Facts, Found, GivenRelease, History, HistoryInput, KINDS, Kind, KindOutput, Next, NotesOutput, OptionsError, OptionsInput, OptionsShape, OptionsValue, PHASES, Pending, Phase, Preset, PresetDefaults, PresetOptions, PrettyReporterOptions, Previous, Release, ReleaseConfig, ReleaseError, ReleaseKind, ReleaseOutput, ReleaseReport, ReleaseResult, ReleaseSetup, ReleaseStatus, Reporter, ResolvedComponent, type RunChannel, RunOptions, Scheme, Scope, ScopedStep, Step, StepCondition, StepDefinition, StepFactory, StepFactoryDefinition, StepInput, StepOutput, StepOutputs, StepPreset, StepRecord, StepResults, StepStatus, WorkflowInput, WorkflowOptions, WorkflowRelease, WriteOutput, compileExpression, index_d_exports as components, defaultReporter, defineComponents, defineHistory, definePreset, defineRelease, defineScheme, defineStep, errorMessage, expressionContext, formatDuration, git, index_d_exports$1 as histories, joinPath, markdownSummary, parseOptions, index_d_exports$2 as presets, prettyReporter, resolveComponents, resolveWorkflow, resolveWorkflowSteps, runRelease, index_d_exports$3 as schemes, sortSteps, index_d_exports$4 as steps, tryGit, when, z };