@astra-kit/rp 0.0.0-stage → 0.10.0

package/types/create-version/registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Coordinates one selected registry through a shared lookup/authentication/publication contract.
+ *
+ * @module create-version/registry
+ */
+import { checkNpmPublishAccess, lookupPublishedVersions } from "./npm.js";
+export type RegistrySelection = {
+    provider: import("./registry-config.js").RegistryProvider;
+    options: import("./registry-config.js").ResolvedPublicationOptions;
+};
+export type SelectedRegistry = RegistrySelection & {
+    registryUrl: string;
+    packageName: string;
+    label: string;
+    tag: string | null;
+};
+/**
+ * @typedef {{ provider: import("./registry-config.js").RegistryProvider, options: import("./registry-config.js").ResolvedPublicationOptions }} RegistrySelection
+ * @typedef {RegistrySelection & { registryUrl: string, packageName: string, label: string, tag: string | null }} SelectedRegistry
+ */
+/**
+ * Selects the configured provider without changing legacy npm hooks or disabled tracking.
+ *
+ * @param {import("./config.js").ResolvedCreateVersionConfig} config - Project configuration.
+ * @returns {RegistrySelection} Selected provider and options.
+ */
+export declare function selectProjectRegistry(config: import("./config.js").ResolvedCreateVersionConfig): RegistrySelection;
+/**
+ * Resolves package identity and endpoint once for the operation; known npm endpoints use their provider policy.
+ *
+ * @param {RegistrySelection} selection - Project selection.
+ * @param {Record<string, unknown>} manifest - Node package manifest.
+ * @param {string} repositoryRoot - Root where registry routing and credentials are read.
+ * @param {string} [packageRoot] - Workspace or checkout directory.
+ * @returns {Promise<SelectedRegistry>} Registry descriptor without secret values.
+ * @throws {Error} When the endpoint or package identity is invalid for its provider.
+ */
+export declare function resolveRegistry(selection: RegistrySelection, manifest: Record<string, unknown>, repositoryRoot: string, packageRoot?: string): Promise<SelectedRegistry>;
+/**
+ * Reads the selected registry through the common version contract, preserving injected legacy npm adapters.
+ *
+ * @param {RegistrySelection} selection - Selected provider.
+ * @param {Record<string, unknown>} manifest - Source manifest.
+ * @param {string} repositoryRoot - Repository containing credentials and routing.
+ * @param {string} [packageRoot] - Workspace package root.
+ * @param {typeof lookupPublishedVersions} [lookupNpm] - Legacy npm boundary.
+ * @returns {Promise<import("./npm.js").NpmLookup>} Published-version state.
+ */
+export declare function lookupRegistryVersions(selection: RegistrySelection, manifest: Record<string, unknown>, repositoryRoot: string, packageRoot?: string, lookupNpm?: typeof lookupPublishedVersions): Promise<import("./npm.js").NpmLookup>;
+/**
+ * Checks the destination of an npm-protocol OIDC publication: npm trusted publishing only exists on
+ * the public npm registry, so GitHub Packages, GitLab and any other endpoint can never accept it.
+ * Shared by the worker and by CI preparation, which must reject it before the release tag exists.
+ *
+ * @param {SelectedRegistry} registry - Resolved descriptor of a non-JSR provider.
+ * @returns {string | null} Blocking reason, or `null` when the destination is the public npm registry.
+ */
+export declare function findNpmOidcRegistryProblem(registry: SelectedRegistry): string | null;
+/**
+ * Checks only capabilities the selected provider exposes; unsupported permission checks remain unknown.
+ *
+ * @param {RegistrySelection} selection - Project selection.
+ * @param {Record<string, unknown>} manifest - Node package manifest.
+ * @param {string} repositoryRoot - Credential root.
+ * @param {string} [packageRoot] - Package checkout.
+ * @param {typeof checkNpmPublishAccess} [checkNpmAccess] - Legacy npm check boundary.
+ * @returns {Promise<import("./npm.js").NpmAuthCheck>} Safe credential diagnostic.
+ */
+export declare function checkRegistryAccess(selection: RegistrySelection, manifest: Record<string, unknown>, repositoryRoot: string, packageRoot?: string, checkNpmAccess?: typeof checkNpmPublishAccess): Promise<import("./npm.js").NpmAuthCheck>;
+/**
+ * Publishes with the chosen protocol and reconciles a failed client before declaring an unpublished version.
+ *
+ * @param {RegistrySelection} selection - One configured provider.
+ * @param {Record<string, unknown>} manifest - Release manifest.
+ * @param {string} repositoryRoot - Routing and credential root.
+ * @param {string} packageRoot - Actual release checkout.
+ * @param {string} version - Stable release version.
+ * @param {string | null} [artifactPath] - Verified npm archive; unused by native JSR.
+ * @returns {Promise<{ registry: SelectedRegistry, exitCode: number, missingToken: boolean, confirmed: boolean }>} Publication and reconciliation result.
+ */
+export declare function publishRegistryRelease(selection: RegistrySelection, manifest: Record<string, unknown>, repositoryRoot: string, packageRoot: string, version: string, artifactPath?: string | null): Promise<{
+    registry: SelectedRegistry;
+    exitCode: number;
+    missingToken: boolean;
+    confirmed: boolean;
+}>;

package/types/create-version/release-execution.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Records and reads, in the release commit itself, where a release was prepared (`local` or `ci`).
+ * The mark lives in a commit trailer so it covers every release without adding tracked files that the
+ * Vercel build gate would interpret.
+ * @module create-version/release-execution
+ */
+/**
+ * Builds the trailer paragraph appended to the release commit message.
+ * @param {"local" | "ci"} execution - Location where the release commit is prepared.
+ * @returns {string} Trailer line such as `Astra-Rp-Execution: ci`.
+ */
+export declare function formatReleaseExecutionTrailer(execution: "local" | "ci"): string;
+/**
+ * Reads the execution location recorded in the trailer of a release commit.
+ * Commits created before the trailer existed (or by other tools) have none and yield null.
+ * @param {import("./process.js").GitReader} reader - Git reader of the release checkout.
+ * @param {string} version - Version of the release commit, used in diagnostics.
+ * @param {string} [revision] - Commit holding the trailer; defaults to `HEAD`.
+ * @returns {Promise<"local" | "ci" | null>} Recorded location, or null when the commit carries no trailer.
+ * @throws {ReleaseStepError} When the commit cannot be read, or its trailers are unknown or contradictory.
+ */
+export declare function readReleaseExecutionTrailer(reader: import("./process.js").GitReader, version: string, revision?: string): Promise<"local" | "ci" | null>;

package/types/create-version/release-tag-config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Loads the `create-version` configuration stored in a release tag. `--retry-ci` dispatches the
+ * workflow of the tag with `--ref <tag>` and the worker reloads its configuration from that tag, so
+ * the workflow name and the Actions bindings checked before the retry must come from the tag too,
+ * not from a working tree that later commits may have changed without bumping the version.
+ * @module create-version/release-tag-config
+ */
+/**
+ * Checks out a release tag into a temporary directory inside the repository's Git directory and
+ * loads the configuration stored there. The checkout uses its own index, so the project's index,
+ * working tree and refs stay untouched, and it is removed before returning. Placing it under the
+ * project lets the tagged configuration import the dependencies installed in the project root.
+ * @param {string} repositoryRoot - Project root.
+ * @param {string} tag - Release tag already verified against origin, such as `v1.2.4`.
+ * @returns {Promise<import("./config.js").ResolvedCreateVersionConfig>} Configuration the worker loads from the tag.
+ * @throws {ReleaseStepError} When the tag cannot be checked out or its configuration is missing or invalid.
+ */
+export declare function loadReleaseTagConfig(repositoryRoot: string, tag: string): Promise<import("./config.js").ResolvedCreateVersionConfig>;

package/types/create-version/run.d.ts

@@ -0,0 +1,407 @@
+/**
+ * `astra-rp create-version`: one command that diagnoses a repository, shows
+ * what is still missing and ships the release from `main`.
+ *
+ * 1. Diagnosis: fetches `origin`, reads the branch, working tree, `main`
+ *    versus `origin/main`, the last release, unreleased commits, the
+ *    published versions, the npm credentials (when the plan would publish to
+ *    npm) and pending migrations (`state.js`).
+ * 2. Plan: `plan.js` turns that snapshot into ordered steps, or into blockers
+ *    that explain what to fix.
+ * 3. Execution: runs each step; project-specific work (checks, migrations,
+ *    preparation, publication) comes from `astra-rp.config.js`.
+ *
+ * Every step is derived from the current state, so running the command again
+ * after a failure resumes from the first missing step.
+ *
+ * @module create-version/run
+ */
+import { setAsideLocalChanges } from "./local-changes.js";
+export type ResolvedCreateVersionConfig = import("./config.js").ResolvedCreateVersionConfig;
+export type HookContext = import("./config.js").HookContext;
+export type ReleaseSnapshot = import("./state.js").ReleaseSnapshot;
+export type GitReader = import("./process.js").GitReader;
+export type ReleaseContext = {
+    repositoryRoot: string;
+    config: ResolvedCreateVersionConfig;
+    state: ReleaseSnapshot;
+    options: import("./plan.js").ReleaseOptions;
+    reader: GitReader;
+    version: string | null;
+    pushed: boolean;
+    published: boolean;
+    commitCount: number | null;
+    packageName: string;
+    registryUrl: string | null;
+    registryLabel: string | null;
+    commands: import("../package-manager.js").ProjectCommands;
+    changelogFiles: import("./changelog.js").PreservedReleaseFile[];
+    execution?: "local" | "ci";
+    ciWorker?: boolean;
+    ciSetupFiles?: ReleaseFileUpdate[];
+    workflowClient?: import("./github-workflow.js").GithubWorkflowClient;
+};
+export type StepContext = {
+    repositoryRoot: string;
+    reader: GitReader;
+    config: ResolvedCreateVersionConfig;
+    commands: import("../package-manager.js").ProjectCommands;
+    state: {
+        migrations: import("./config.js").MigrationCheck | null;
+    };
+    execution?: "local" | "ci";
+    ciWorker?: boolean;
+    version?: string | null;
+};
+export type RenderablePlan = {
+    mode: string;
+    steps: import("./plan.js").ReleasePlanStep[];
+    blockers: import("./plan.js").ReleaseBlocker[];
+    warnings: string[];
+};
+/**
+ * @typedef {import("./config.js").ResolvedCreateVersionConfig} ResolvedCreateVersionConfig
+ * @typedef {import("./config.js").HookContext} HookContext
+ * @typedef {import("./state.js").ReleaseSnapshot} ReleaseSnapshot
+ * @typedef {import("./process.js").GitReader} GitReader
+ * @typedef {{
+ *   repositoryRoot: string,
+ *   config: ResolvedCreateVersionConfig,
+ *   state: ReleaseSnapshot,
+ *   options: import("./plan.js").ReleaseOptions,
+ *   reader: GitReader,
+ *   version: string | null,
+ *   pushed: boolean,
+ *   published: boolean,
+ *   commitCount: number | null,
+ *   packageName: string,
+ *   registryUrl: string | null,
+ *   registryLabel: string | null,
+ *   commands: import("../package-manager.js").ProjectCommands,
+ *   changelogFiles: import("./changelog.js").PreservedReleaseFile[],
+ *   execution?: "local" | "ci",
+ *   ciWorker?: boolean,
+ *   ciSetupFiles?: ReleaseFileUpdate[],
+ *   workflowClient?: import("./github-workflow.js").GithubWorkflowClient,
+ * }} ReleaseContext
+ * @typedef {{
+ *   repositoryRoot: string,
+ *   reader: GitReader,
+ *   config: ResolvedCreateVersionConfig,
+ *   commands: import("../package-manager.js").ProjectCommands,
+ *   state: { migrations: import("./config.js").MigrationCheck | null },
+ *   execution?: "local" | "ci",
+ *   ciWorker?: boolean,
+ *   version?: string | null,
+ * }} StepContext
+ *   What the steps shared with the monorepo mode read: both release contexts satisfy it.
+ * @typedef {{ mode: string, steps: import("./plan.js").ReleasePlanStep[], blockers: import("./plan.js").ReleaseBlocker[], warnings: string[] }} RenderablePlan
+ */
+/** Raised when the user cancels on purpose; ends the run without an error box. */
+export declare class ReleaseCancelledError extends Error {
+}
+/**
+ * Raised after syncing `main` brought new commits: the diagnosis, the plan and the configuration
+ * (with every module it imports) belong to the previous `main`, so the run ends without an error
+ * and asks to run the command again in a new process.
+ */
+export declare class MainSyncedRestartError extends Error {
+}
+/**
+ * Prints a failure that ends the run before any step: its message and, for a {@link ReleaseStepError}, its hint.
+ *
+ * @param {unknown} error - Thrown value.
+ * @param {{ red?: boolean }} [display] - Whether the message and hint are painted red.
+ * @returns {void}
+ */
+export declare function printFailure(error: unknown, { red }?: {
+    red?: boolean;
+}): void;
+/**
+ * Lists the uncommitted changes and asks whether to set them aside for this release, as
+ * `--ignore-local-changes` does. Nothing is preselected, so a stray Enter never ignores them.
+ *
+ * @param {string[]} changes - `git status --porcelain` lines that would be set aside.
+ * @returns {Promise<boolean>} `true` to set them aside and go on.
+ */
+export declare function askToIgnoreLocalChanges(changes: string[]): Promise<boolean>;
+/**
+ * Creates the context passed to project hooks.
+ *
+ * @param {string} repositoryRoot - Repository root.
+ * @param {GitReader} reader - Git reader.
+ * @param {string | null} version - Version being released, when known.
+ * @returns {HookContext} Hook context.
+ */
+export declare function createHookContext(repositoryRoot: string, reader: GitReader, version: string | null): HookContext;
+/**
+ * Renders a list of commit subjects inside a box.
+ *
+ * @param {{ subject: string }[]} commits - Commits, newest first.
+ * @param {string} title - Box title.
+ * @returns {string} Box.
+ */
+export declare function renderCommitList(commits: {
+    subject: string;
+}[], title: string): string;
+/**
+ * Compares the running Node.js with `.nvmrc`, which may pin a full version or only a major.
+ *
+ * @param {string} repositoryRoot - Repository root.
+ * @returns {{ matches: boolean, pinned: string } | null} Comparison, or `null` without `.nvmrc`.
+ */
+export declare function checkPinnedNodeVersion(repositoryRoot: string): {
+    matches: boolean;
+    pinned: string;
+} | null;
+/**
+ * Renders the repository rows both diagnoses start with: the branch, the working tree and `main`
+ * compared with `origin/main`.
+ *
+ * @param {{ currentBranch: string | null, workingTreeChanges: string[], main: { aheadCommits: unknown[], behindCount: number } }} state - Repository part of a snapshot.
+ * @param {string | null} [detachedTag] - Release tag a detached `HEAD` sits on, which is only a warning.
+ * @returns {string[]} Rows.
+ */
+export declare function renderRepositoryRows(state: {
+    currentBranch: string | null;
+    workingTreeChanges: string[];
+    main: {
+        aheadCommits: unknown[];
+        behindCount: number;
+    };
+}, detachedTag?: string | null): string[];
+/**
+ * Renders the Node.js row of the diagnosis when the project pins a version in `.nvmrc`.
+ *
+ * @param {string} repositoryRoot - Repository root.
+ * @returns {string | null} Row, or `null` without `.nvmrc`.
+ */
+export declare function renderNodeVersionRow(repositoryRoot: string): string | null;
+/**
+ * Renders the npm credential row of the diagnosis: the user and where the token came from, or the problem.
+ * An owner passes without claiming that the token can write, which npm cannot check before publishing.
+ *
+ * @param {import("./npm.js").NpmAuthCheck} npmAuth - Credential check.
+ * @returns {string} Row.
+ */
+export declare function renderNpmAuthRow(npmAuth: import("./npm.js").NpmAuthCheck): string;
+/**
+ * Renders the plan or its blockers.
+ *
+ * @param {RenderablePlan} plan - Plan.
+ * @returns {string} Box.
+ */
+export declare function renderPlan(plan: RenderablePlan): string;
+/**
+ * Runs Git with visible output and fails the step on error.
+ *
+ * @param {StepContext} context - Release context.
+ * @param {string[]} gitArguments - Git arguments.
+ * @param {string} failureMessage - Spanish message when it fails.
+ * @param {string} hint - Spanish next action.
+ * @returns {Promise<void>}
+ */
+export declare function runGitStep(context: StepContext, gitArguments: string[], failureMessage: string, hint: string): Promise<void>;
+/**
+ * Creates an annotated release tag, failing the step when Git rejects it.
+ *
+ * @param {StepContext} context - Release context.
+ * @param {string} tag - Tag to create.
+ * @param {string} annotation - Tag message.
+ * @param {string} hint - Spanish next action when it fails.
+ * @param {string | null} [target] - Commit to tag; `HEAD` when `null`.
+ * @returns {Promise<void>}
+ */
+export declare function createAnnotatedTag(context: StepContext, tag: string, annotation: string, hint: string, target?: string | null): Promise<void>;
+/**
+ * Runs configured command lines in order, stopping at the first failure.
+ *
+ * @param {StepContext} context - Release context.
+ * @param {string[]} commandLines - Commands from `astra-rp.config.js`.
+ * @param {string} hint - Spanish next action when one fails.
+ * @returns {Promise<void>}
+ */
+export declare function runConfiguredCommands(context: StepContext, commandLines: string[], hint: string): Promise<void>;
+/**
+ * Steps a configuration adds to the release plan.
+ *
+ * @param {ResolvedCreateVersionConfig} config - Resolved configuration.
+ * @param {string} [registryLabel] - Provider discovered from the resolved endpoint.
+ * @returns {import("./plan.js").ReleaseCapabilities} Capabilities for `buildReleasePlan`.
+ */
+export declare function describeReleaseCapabilities(config: ResolvedCreateVersionConfig, registryLabel?: string): import("./plan.js").ReleaseCapabilities;
+/**
+ * Fast-forwards local `main` to `origin/main`. When that brings new commits the release stops
+ * before touching the version: the diagnosis, the plan and `astra-rp.config.(m)js` (imported with
+ * its modules at startup) come from the previous `main`, so the command must run again in a new
+ * process to diagnose with the new code and configuration.
+ *
+ * @param {StepContext} context - Release context.
+ * @returns {Promise<void>}
+ * @throws {ReleaseStepError} When the fast-forward fails.
+ * @throws {MainSyncedRestartError} When `main` moved and the command has to run again.
+ */
+export declare function syncMainStep(context: StepContext): Promise<void>;
+/**
+ * Shows the pending migrations, asks for confirmation and applies them through the project adapter.
+ *
+ * @param {StepContext} context - Release context.
+ * @returns {Promise<void>}
+ */
+export declare function applyMigrationsStep(context: StepContext): Promise<void>;
+/**
+ * Runs the configured checks before touching the version.
+ *
+ * @param {StepContext} context - Release context.
+ * @returns {Promise<void>}
+ */
+export declare function runChecksStep(context: StepContext): Promise<void>;
+export type ReleaseFileUpdate = {
+    filePath: string;
+    originalBytes: Buffer | null;
+    content: string;
+};
+export type VersionFilesContext = Pick<StepContext, "repositoryRoot" | "config" | "reader" | "commands">;
+/**
+ * Reads a file the release rewrites, as its exact bytes and as strict UTF-8 text: writing back the
+ * text of a file that is not UTF-8 (such as ISO-8859-1) would replace its other bytes.
+ *
+ * @param {VersionFilesContext} context - Release context.
+ * @param {string} filePath - File relative to the root, `/`-separated.
+ * @param {string} fileLabel - How the messages name the file, such as `src/cli.js (versionFiles)`.
+ * @returns {{ originalBytes: Buffer, text: string }} Bytes on disk and their text.
+ * @throws {ReleaseStepError} When the file is not valid UTF-8.
+ */
+export declare function readReleaseFile(context: VersionFilesContext, filePath: string, fileLabel: string): {
+    originalBytes: Buffer;
+    text: string;
+};
+/**
+ * Writes a new version into the top-level `version` of a manifest, keeping the rest of its bytes.
+ * The text replacement changes the first `"version"` field of the file, so the result is parsed to
+ * confirm it was the top-level one and not nested metadata.
+ *
+ * @param {VersionFilesContext} context - Release context.
+ * @param {string} filePath - Manifest path relative to the root, as the messages name it.
+ * @param {string} text - Manifest content.
+ * @param {string} version - Version to write.
+ * @returns {string} Manifest content with the new top-level `version`.
+ * @throws {ReleaseStepError} When the first `"version"` of the file is not the top-level one.
+ */
+export declare function rewriteManifestVersion(context: VersionFilesContext, filePath: string, text: string, version: string): string;
+/**
+ * Computes the new content of `versionFiles` entries before anything is written, so
+ * a missing, non-regular (symlink or directory), untracked, non-UTF-8 or unmarked file stops the release with the version untouched.
+ *
+ * @param {VersionFilesContext} context - Release context.
+ * @param {readonly string[]} versionFiles - Entries that get `version`: every configured one, or in a
+ *   monorepo the ones inside the package being released.
+ * @param {string} version - Version being released.
+ * @returns {Promise<ReleaseFileUpdate[]>} Files to write, with their bytes before the release.
+ * @throws {ReleaseStepError} When a file is missing, is not a regular file, is not tracked by Git, is not valid UTF-8, has
+ *   block markers paired wrongly or none of its lines is marked.
+ */
+export declare function prepareVersionFileUpdates(context: VersionFilesContext, versionFiles: readonly string[], version: string): Promise<ReleaseFileUpdate[]>;
+/**
+ * Stops the release when an earlier step (such as a check running a formatter with `--fix`) changed
+ * a `package.json` or a `versionFiles` entry: the plan requires them clean, so any difference from
+ * `HEAD` would be read as the original content and shipped in the release commit.
+ *
+ * @param {VersionFilesContext} context - Release context.
+ * @param {readonly string[]} filePaths - Manifests and `versionFiles` entries the release rewrites.
+ * @returns {Promise<void>}
+ * @throws {ReleaseStepError} When any of those files differs from `HEAD`.
+ */
+export declare function assertReleaseFilesMatchHead(context: VersionFilesContext, filePaths: readonly string[]): Promise<void>;
+/**
+ * Writes the release files (versions and closed changelogs), stages them literally and creates the
+ * release commit, checking that it holds exactly the prepared tree. Any failure (or a hook that changes
+ * the commit, or rewrites a closed changelog in the working tree) rolls the files and their staging
+ * back and undoes the commit, so no tag is created.
+ *
+ * @param {StepContext} context - Release context.
+ * @param {ReleaseFileUpdate[]} releaseFiles - Files of the release commit, with their bytes before the release.
+ * @param {string} subject - Subject of the release commit.
+ * @param {readonly ReleaseFileUpdate[]} [closedChangelogs] - Changelogs among `releaseFiles` whose working-tree bytes
+ *   must still hold their closed `[Unreleased]` after the commit.
+ * @param {readonly string[]} [trailers] - Trailer lines (`Key: value`) appended as the last paragraph of the commit message.
+ * @returns {Promise<void>}
+ * @throws {ReleaseStepError} When writing, staging or committing fails, or the commit differs from the prepared tree.
+ */
+export declare function commitReleaseFiles(context: StepContext, releaseFiles: ReleaseFileUpdate[], subject: string, closedChangelogs?: readonly ReleaseFileUpdate[], trailers?: readonly string[]): Promise<void>;
+/**
+ * Checks that no tracked file differs from `HEAD` before publishing. `prepare` may create untracked
+ * or ignored output (`dist/`, `releases/`), but a modified tracked file (such as `package.json`)
+ * means the publication would no longer be the release commit.
+ *
+ * @param {{ reader: GitReader, commands: import("../package-manager.js").ProjectCommands }} context - Git reader of
+ *   the checkout being published and the project commands quoted by the hint.
+ * @returns {Promise<void>}
+ * @throws {ReleaseStepError} When Git cannot report the working tree state or a tracked file changed.
+ */
+export declare function assertNoTrackedChanges(context: {
+    reader: GitReader;
+    commands: import("../package-manager.js").ProjectCommands;
+}): Promise<void>;
+/**
+ * Runs `create-version` in a repository.
+ *
+ * @param {{ repositoryRoot: string, argv: string[] }} options - Repository root and arguments after the command name.
+ * @returns {Promise<number>} Process exit code.
+ */
+export declare function runCreateVersion({ repositoryRoot, argv }: {
+    repositoryRoot: string;
+    argv: string[];
+}): Promise<number>;
+/**
+ * Sets the uncommitted changes aside while an operation runs and restores them afterwards, whatever
+ * its outcome; shared with the monorepo mode.
+ *
+ * @param {{
+ *   reader: GitReader,
+ *   repositoryRoot: string,
+ *   changeCount: number,
+ *   setAsideOptions: Parameters<typeof setAsideLocalChanges>[1],
+ *   messages: { setAside: string, restored: string, recovery: string },
+ * }} localChanges - Repository, how many changes to set aside (none skips it), the options of
+ *   {@link setAsideLocalChanges} and the Spanish messages printed after setting aside, after
+ *   restoring and when the restore fails.
+ * @param {() => Promise<number>} operation - Work run with the changes set aside.
+ * @returns {Promise<number>} Exit code of the operation, or a failure when the changes could not be set aside.
+ */
+export declare function withLocalChangesSetAside({ reader, repositoryRoot, changeCount, setAsideOptions, messages }: {
+    reader: GitReader;
+    repositoryRoot: string;
+    changeCount: number;
+    setAsideOptions: Parameters<typeof setAsideLocalChanges>[1];
+    messages: {
+        setAside: string;
+        restored: string;
+        recovery: string;
+    };
+}, operation: () => Promise<number>): Promise<number>;
+/**
+ * Runs the plan steps in order and prints the outcome; shared with the monorepo mode.
+ *
+ * @template {{ commands: import("../package-manager.js").ProjectCommands }} Context
+ * @param {Context} context - Release context passed to every step.
+ * @param {{
+ *   steps: import("./plan.js").ReleasePlanStep[],
+ *   executors: Record<string, (context: Context) => Promise<void>>,
+ *   untouchedNote: string,
+ *   describeFailureFollowUp: (context: Context) => Promise<string[]>,
+ *   renderSummary: (context: Context) => string | null,
+ * }} planRun - Steps and their executors, what a restart after syncing `main` left untouched, the lines
+ *   that close a failure box, and the closing summary (`null` for the generic one).
+ * @param {number} startedAt - Start time of the command, in milliseconds.
+ * @returns {Promise<number>} Process exit code.
+ */
+export declare function runPlanSteps<Context extends {
+    commands: import("../package-manager.js").ProjectCommands;
+}>(context: Context, { steps, executors, untouchedNote, describeFailureFollowUp, renderSummary }: {
+    steps: import("./plan.js").ReleasePlanStep[];
+    executors: Record<string, (context: Context) => Promise<void>>;
+    untouchedNote: string;
+    describeFailureFollowUp: (context: Context) => Promise<string[]>;
+    renderSummary: (context: Context) => string | null;
+}, startedAt: number): Promise<number>;