@wpelevator/wp-release 0.10.0 → 0.11.0

package/dist/changeset-release.js

@@ -1,1016 +1,418 @@
-import { randomUUID } from 'node:crypto';
-import { execFile } from 'node:child_process';
-import { access, mkdir, readdir, readFile, rm, writeFile, } from 'node:fs/promises';
 import path from 'node:path';
-import { promisify } from 'node:util';
+import { getVersionedReleases, prependChangelog } from "./changelog.js";
 import { loadChangesetConfig } from "./changeset-config.js";
-import { findMainPluginFile } from "./package-meta.js";
-import { findConstantValues } from "./version-check.js";
-import { formatChangelogList, formatChangeset, getChangesetBump, getNextVersion, parseChangeset, } from "./changesets.js";
+import { applyDependents, assertDependentsSourcesReleased, collectPinDriftWarnings, expandDependentsPlan, findBundledPinChanges, hasChangeset, selectReleasePlan, stripDependentsPlan, updateDependencyDeclaration, } from "./changeset-dependents.js";
+import { consumeChangeset, readChangesets, readChangesetsSince, writeChangeset, } from "./changeset-files.js";
+import { assertKnownPackages, discoverPackages, getChangedPackages, toChangesetPackage, } from "./changeset-packages.js";
+import { getChangesetBump, getNextVersion } from "./changesets.js";
 import { ValidationError } from "./errors.js";
-import semverSatisfies from 'semver/functions/satisfies.js';
-import validRange from 'semver/ranges/valid.js';
-const execFileAsync = promisify(execFile);
-/** npm dependency sections whose declared dependency re-releases the dependent. */
-const DEFAULT_SECTIONS = ['dependencies', 'optionalDependencies'];
-/**
- * Discover configured packages, pending changesets, and their proposed versions.
- *
- * @param input Repository root and optional explicit config file.
- * @return A release plan; `undefined` when no config is present.
- */
-export async function getChangesetReleasePlan(input) {
-    const context = await getReleaseContext(input);
-    return context?.plan;
-}
-/**
- * Discover the packages of the repository configuration.
- *
- * @param  input Repository root and optional explicit config file.
- * @return Packages in the configured order with their current versions.
- * @throws {ValidationError} Without a config, or for an invalid one.
- */
-export async function getChangesetPackages(input) {
-    const loaded = await requireConfig(input);
-    const packages = await discoverPackages(input.cwd, loaded.config);
-    return packages.map(toChangesetPackage);
-}
-async function getReleaseContext(input) {
-    const loaded = await loadChangesetConfig(input);
-    if (!loaded) {
-        return undefined;
+import { FileJournal } from "./file-journal.js";
+import { getPreviousTag, getReleaseNotes, getTagVersion, selectTagPackages, } from "./release-tags.js";
+import { ReleaseRepository } from "./release-repository.js";
+import { formatTag } from "./tag-format.js";
+import { verifyVersionTargets, writeVersion } from "./version-files.js";
+import { isPrerelease } from "./versions.js";
+const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or pass --config <path>.';
+/**
+ * Changeset releases of a repository: recording changesets, versioning the
+ * packages they name and tagging the releases.
+ *
+ * Each operation loads the configuration, discovers the packages and reads the
+ * pending changesets again, so that one instance can version and then tag.
+ * Git runs through the injected runner.
+ */
+export class ChangesetRelease {
+    cwd;
+    configFile;
+    repository;
+    /**
+     * @param options Repository root, config file and git runner.
+     */
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.configFile = options.configFile;
+        this.repository = new ReleaseRepository({
+            cwd: options.cwd,
+            runner: options.git,
+        });
     }
-    const config = loaded.config;
-    const packages = await discoverPackages(input.cwd, config);
-    const changesets = await readChangesets(input.cwd, config);
-    const releases = [];
-    packages.forEach((pkg) => {
-        const bump = getChangesetBump(changesets, pkg.name);
-        if (bump) {
-            const packageChangesets = changesets.filter((changeset) => Object.hasOwn(changeset.packages, pkg.name));
-            const nextVersion = config.nextVersion
-                ? config.nextVersion({
-                    package: pkg,
-                    bump,
-                    currentVersion: pkg.currentVersion,
-                    changesets: packageChangesets,
-                })
-                : getNextVersion(pkg.currentVersion, bump);
-            if ('string' !== typeof nextVersion || !nextVersion.trim()) {
-                throw new ValidationError(`The nextVersion strategy returned an empty version for package "${pkg.name}".`);
+    /**
+     * Discover configured packages, pending changesets, and their proposed
+     * versions.
+     *
+     * @return A release plan; `undefined` when no config is present.
+     */
+    async getPlan() {
+        const context = await this.loadContext();
+        return context?.plan;
+    }
+    /**
+     * Discover the packages of the repository configuration.
+     *
+     * @return Packages in the configured order with their current versions.
+     * @throws {ValidationError} Without a config, or for an invalid one.
+     */
+    async getPackages() {
+        const config = await this.requireConfig();
+        const packages = await discoverPackages(this.repository, config);
+        return packages.map(toChangesetPackage);
+    }
+    /**
+     * Create a Changesets-compatible Markdown file.
+     *
+     * @param  options Packages, summary and file name.
+     * @return Created file path.
+     * @throws {ValidationError} For unknown packages or an existing file.
+     */
+    async add(options) {
+        const config = await this.requireConfig();
+        const packages = await discoverPackages(this.repository, config);
+        assertKnownPackages(packages, Object.keys(options.packages));
+        return writeChangeset(this.getChangesetDirectory(config), options.packages, options.summary, options.name);
+    }
+    /**
+     * Apply pending package versions and changelogs. A failed run restores
+     * every file it changed.
+     *
+     * @param  options Versioning options.
+     * @return Planned releases and whether files were changed.
+     * @throws {ValidationError} Without a config, or for an invalid plan.
+     */
+    async version(options = {}) {
+        const context = await this.requireContext();
+        const { config, packages } = context;
+        const withDependents = options.dependents ?? true;
+        let releasePlan = context.plan;
+        if (options.packages) {
+            releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, options.packages, config, withDependents));
+        }
+        else if (!withDependents) {
+            releasePlan = stripDependentsPlan(context.plan);
+        }
+        // A dependent must not release while one of the packages it depends on has
+        // pending changesets that aren't released in the same run, or it would
+        // bundle unreleased code under a changelog that cannot credit it. The
+        // check only applies to repositories that adopted the dependents policy.
+        if (withDependents && config.dependents) {
+            await assertDependentsSourcesReleased(releasePlan, context.plan, packages, config);
+        }
+        const date = options.date ?? new Date().toISOString().slice(0, 10);
+        const releases = await getVersionedReleases(this.repository, config, releasePlan.releases, this.getChangesetDirectory(config));
+        if (!options.dryRun) {
+            await this.writeReleases(context, releasePlan, releases, date, options.packages);
+        }
+        return {
+            changesets: releasePlan.changesets,
+            releases,
+            date,
+            changed: !options.dryRun &&
+                (releasePlan.changesets.length > 0 ||
+                    releasePlan.releases.length > 0),
+        };
+    }
+    /**
+     * Create missing release tags, optionally pushing them to the origin
+     * remote. Each tag comes with the title and notes of its release, for a
+     * workflow step to create the GitHub Release.
+     *
+     * @param  options Tag options.
+     * @return Per-package tags and release notes.
+     * @throws {ValidationError} For conflicting options, unknown packages or version mismatches.
+     */
+    async tag(options = {}) {
+        if (options.untagged && options.push) {
+            throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
+        }
+        const context = await this.requireContext();
+        const selected = selectTagPackages(context.packages, options.packages ?? [], options.version);
+        const packages = options.since
+            ? (await getChangedPackages(this.repository, selected, options.since)).packages
+            : selected;
+        const results = [];
+        const dryRun = options.dryRun || options.untagged;
+        const tagFormat = context.config.tagFormat ?? '{path}/{version}';
+        for (const pkg of packages) {
+            const version = await getTagVersion(pkg, options.version);
+            if (undefined !== options.version &&
+                options.version !== version) {
+                throw new ValidationError(`Package "${pkg.name}" is at version ${version}, not ${options.version}.`);
             }
-            releases.push({
-                package: pkg,
-                bump,
-                currentVersion: pkg.currentVersion,
-                nextVersion,
-                changesets: packageChangesets,
-            });
-        }
-    });
-    changesets.forEach((changeset) => {
-        Object.keys(changeset.packages).forEach((name) => {
-            if (!packages.some((pkg) => pkg.name === name)) {
-                throw new ValidationError(`Changeset ${changeset.fileName} refers to unknown package "${name}".`);
+            const tag = formatTag(tagFormat, pkg, version);
+            const exists = await this.repository.tagExists(tag);
+            if (!exists) {
+                await verifyVersionTargets(this.repository, pkg, version);
             }
-        });
-    });
-    await applyDependents(releases, packages, config);
-    return { config, packages, plan: { changesets, releases } };
-}
-/**
- * Add releases for dependents of packages that release, applying the
- * configured dependents policy until the plan settles.
- *
- * @param releases Planned releases, mutated in place.
- * @param packages Discovered packages.
- * @param config   Repository release configuration.
- */
-async function applyDependents(releases, packages, config) {
-    const rule = config.dependents;
-    if (!rule) {
-        return;
-    }
-    // Dependents may themselves be dependents of other sources, so expand until stable.
-    let grew = true;
-    while (grew) {
-        grew = false;
-        for (const source of [...releases]) {
-            for (const dependent of packages) {
-                if (await deriveDependentRelease(source, dependent, releases, rule)) {
-                    grew = true;
-                }
+            const previousTag = await getPreviousTag(this.repository, formatTag(tagFormat, pkg, ''), version);
+            const notes = await getReleaseNotes(this.repository, context.config, pkg, { version, tag, previousTag }, exists ? tag : 'HEAD');
+            if (!exists && !dryRun) {
+                await this.repository.createTag(tag);
             }
-        }
-    }
-}
-/**
- * Plan the release of a package that bundles a source package, or add the
- * source to the bundle list of its own pending release.
- *
- * @param source    Package release of the source.
- * @param dependent Package that would bundle the source.
- * @param releases  Planned releases, mutated in place.
- * @param rule      Dependents policy.
- * @return Whether a new dependent release was planned.
- */
-async function deriveDependentRelease(source, dependent, releases, rule) {
-    if (dependent.name === source.package.name ||
-        isExcludedDependent(dependent, rule)) {
-        return false;
-    }
-    const specs = await findDependencySpecs(dependent, source.package, rule);
-    if (!specs.length || !dependentNeedsRelease(specs, source, rule)) {
-        return false;
-    }
-    const release = releases.find((item) => item.package.name === dependent.name);
-    if (release) {
-        const sources = release.sources ?? [];
-        if (!sources.includes(source.package.name)) {
-            // A dependent that releases for its own reasons still notes the bundle.
-            release.sources = [...sources, source.package.name];
-        }
-        return false;
-    }
-    const bump = rule.bump ?? 'patch';
-    releases.push({
-        package: dependent,
-        bump,
-        currentVersion: dependent.currentVersion,
-        nextVersion: getNextVersion(dependent.currentVersion, bump),
-        changesets: [],
-        sources: [source.package.name],
-    });
-    return true;
-}
-/**
- * Find the specs through which a package declares a dependency on another.
- *
- * A spec is a dependency of the source that the current version resolves,
- * like a range that covers it or a workspace spec, or one that the
- * configured hook reports. A pin like an older version of the source
- * selects a registry release instead, which keeps the local code out of
- * the dependent's build.
- *
- * @param dependent Package potentially declaring the dependency.
- * @param source    Released source package.
- * @param rule      Dependents policy, with its dependency hook and sections.
- * @return The declared specs, with their manifest files and package names.
- */
-async function findDependencySpecs(dependent, source, rule) {
-    const sourceManifest = await readJsonSafe(path.join(source.directory, 'package.json'));
-    if ('string' !== typeof sourceManifest?.name) {
-        return rule?.dependency?.find
-            ? findDependencyHookSpecs(dependent, source, rule)
-            : [];
-    }
-    const identifier = sourceManifest.name;
-    const specs = [];
-    const parsed = await readJsonSafe(path.join(dependent.directory, 'package.json'));
-    for (const section of dependentsSections(rule)) {
-        const sectionSpecs = parsed?.[section];
-        const declared = 'object' === typeof sectionSpecs &&
-            null !== sectionSpecs &&
-            Object.hasOwn(sectionSpecs, identifier)
-            ? String(sectionSpecs[identifier])
-            : undefined;
-        if (undefined !== declared &&
-            isDependencyOfSource(declared, source.currentVersion)) {
-            specs.push({
-                file: path.join(dependent.directory, 'package.json'),
-                name: identifier,
-                spec: declared,
+            results.push({
+                package: pkg.name,
+                version,
+                tag,
+                title: `${pkg.name}@${version}`,
+                ...(previousTag ? { previousTag } : {}),
+                prerelease: isPrerelease(version),
+                exists,
+                created: !exists && !dryRun,
+                notes,
             });
         }
-    }
-    if (rule?.dependency?.find) {
-        specs.push(...(await findDependencyHookSpecs(dependent, source, rule)));
-    }
-    return specs;
-}
-/**
- * Find the specs that the configured dependency hook reports.
- *
- * @param dependent Package potentially declaring the dependency.
- * @param source    Released source package.
- * @param rule      Dependents policy.
- * @return The hook's specs, with absolute manifest paths and package names.
- */
-async function findDependencyHookSpecs(dependent, source, rule) {
-    const found = await rule.dependency?.find?.({
-        package: dependent,
-        source,
-    });
-    return (found ?? []).map((entry) => ({
-        file: path.resolve(dependent.directory, entry.file),
-        name: entry.name,
-        spec: entry.spec,
-    }));
-}
-/**
- * Check whether a spec points at the workspace copy of a package, by
- * resolving the current version through its range or its workspace protocol.
- *
- * @param spec           Declared spec of the source.
- * @param currentVersion Current version of the source package.
- * @return Whether the spec is a dependency of the source.
- */
-function isDependencyOfSource(spec, currentVersion) {
-    if (spec.startsWith('workspace:')) {
-        return true;
-    }
-    const range = effectiveRange(spec, currentVersion);
-    return (validRange(range) !== null && semverSatisfies(currentVersion, range));
-}
-/**
- * The dependency sections that a dependents policy scans.
- *
- * @param rule Dependents policy.
- * @return Dependency section names.
- */
-function dependentsSections(rule) {
-    return (rule?.sections ?? DEFAULT_SECTIONS);
-}
-/**
- * Check whether a dependent has to release when its declared source releases.
- *
- * @param specs  Declared specs of the source in the dependent.
- * @param source Released source package.
- * @param rule   Dependents policy.
- * @return Whether the dependent needs a release.
- */
-function dependentNeedsRelease(specs, source, rule) {
-    if ('always' === rule.when) {
-        return true;
-    }
-    // Without a range that accepts the next version, like an exact pin, the
-    // dependent has to release and rewrite its specs.
-    return specs.some(({ spec }) => isOutOfRange(source.nextVersion, spec, source.currentVersion));
-}
-/**
- * Check whether a version falls outside a declared range.
- *
- * @param nextVersion    Next version of the source package.
- * @param spec           Declared spec of the source).
- * @param currentVersion Current version of the source package.
- * @return Whether the next version falls outside the range.
- */
-function isOutOfRange(nextVersion, spec, currentVersion) {
-    const range = effectiveRange(spec, currentVersion);
-    if (validRange(range) === null) {
-        // Unrecognized ranges of dependencies like git URLs are left to the consumer.
-        return false;
-    }
-    return !semverSatisfies(nextVersion, range);
-}
-/**
- * Resolve a dependency spec to the range it selects for an internal package.
- *
- * @param spec           Declared spec.
- * @param currentVersion Current version of the source package.
- * @return The effective semver range.
- */
-function effectiveRange(spec, currentVersion) {
-    if (!spec.startsWith('workspace:')) {
-        return spec;
-    }
-    // Workspace specs resolve to the exact published version, and to a
-    // prefixed one with their operator.
-    const bare = spec.slice('workspace:'.length);
-    if ('*' === bare) {
-        return currentVersion;
-    }
-    if ('^' === bare || '~' === bare) {
-        return `${bare}${currentVersion}`;
-    }
-    return bare;
-}
-/**
- * Check whether the dependents policy excludes a package.
- *
- * @param dependent Candidate dependent package.
- * @param rule      Dependents policy.
- * @return Whether the package is excluded from re-releases.
- */
-function isExcludedDependent(dependent, rule) {
-    return (rule.exclude ?? []).some((pattern) => pattern === dependent.name ||
-        globRegExp(pattern).test(dependent.path));
-}
-async function readJsonSafe(file) {
-    try {
-        return JSON.parse(await readFile(file, 'utf8'));
-    }
-    catch (error) {
-        if ('ENOENT' !== error.code) {
-            throw error;
-        }
-        return undefined;
-    }
-}
-/**
- * Create a Changesets-compatible Markdown file.
- *
- * @param input Repository, packages and summary.
- * @return Created file path.
- */
-export async function addChangeset(input) {
-    const loaded = await requireConfig(input);
-    const packages = await discoverPackages(input.cwd, loaded.config);
-    Object.keys(input.packages).forEach((name) => {
-        if (!packages.some((pkg) => pkg.name === name)) {
-            throw new ValidationError(`Unknown package "${name}".`);
-        }
-    });
-    const directory = path.resolve(input.cwd, loaded.config.changesets ?? '.changeset');
-    await mkdir(directory, { recursive: true });
-    const fileName = `${input.name ?? randomUUID().slice(0, 8)}.md`;
-    const file = path.join(directory, fileName);
-    let exists = false;
-    try {
-        await access(file);
-        exists = true;
-    }
-    catch (error) {
-        if ('ENOENT' !== error.code) {
-            throw error;
+        // Push one tag at a time because GitHub doesn't create push events for
+        // tags when more than three are pushed at once.
+        if (options.push && !dryRun) {
+            for (const item of results.filter((result) => result.created)) {
+                await this.repository.pushTag(item.tag);
+            }
         }
-    }
-    if (exists) {
-        throw new ValidationError(`Changeset ${fileName} already exists.`);
-    }
-    const entries = Object.entries(input.packages)
-        .sort((a, b) => a[0].localeCompare(b[0]))
-        .map(([name, bump]) => `${JSON.stringify(name)}: ${bump}`)
-        .join('\n');
-    await writeFile(file, `---\n${entries}\n---\n\n${input.summary.trim()}\n`);
-    return file;
-}
-/**
- * Apply pending package versions and changelogs.
- *
- * @param input Repository and versioning options.
- * @return Planned releases and whether files were changed.
- */
-export async function versionChangesets(input) {
-    const context = await getReleaseContext(input);
-    if (!context) {
-        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
-    }
-    const { config, packages } = context;
-    const withDependents = input.dependents ?? true;
-    let releasePlan = context.plan;
-    if (input.packages) {
-        releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, input.packages, config, withDependents));
-    }
-    else if (!withDependents) {
-        releasePlan = stripDependentsPlan(context.plan);
-    }
-    // A dependent must not release while one of the packages it depends on has
-    // pending changesets that aren't released in the same run, or it would
-    // bundle unreleased code under a changelog that cannot credit it. The
-    // check only applies to repositories that adopted the dependents policy.
-    if (withDependents && config.dependents) {
-        await assertDependentsSourcesReleased(releasePlan, context.plan, packages, config);
-    }
-    const date = input.date ?? new Date().toISOString().slice(0, 10);
-    const changesetDirectory = path.resolve(input.cwd, config.changesets ?? '.changeset');
-    const releases = await getVersionedReleases(input.cwd, config, releasePlan.releases, changesetDirectory);
-    if (!input.dryRun) {
-        const journal = new Map();
+        return {
+            tags: options.untagged
+                ? results.filter((result) => !result.exists)
+                : results,
+        };
+    }
+    /**
+     * Check whether changed files belong to packages without a changeset.
+     *
+     * @param  options Base git ref.
+     * @return Changed packages and missing changeset identifiers.
+     * @throws {ValidationError} Without a config.
+     */
+    async getStatus(options = {}) {
+        const { config, packages, plan } = await this.requireContext();
+        const { changesets, releases } = plan;
+        const since = options.since ??
+            (config.baseBranch ? `origin/${config.baseBranch}` : undefined);
+        const changed = since
+            ? await getChangedPackages(this.repository, packages, since)
+            : { packages: [], filesByPackage: {} };
+        const changedPackages = changed.packages.map((pkg) => pkg.name);
+        const changesetsInDiff = since
+            ? await readChangesetsSince(this.repository, this.getChangesetDirectory(config), changesets, since)
+            : [];
+        const hasEmptyChangeset = changesetsInDiff.some((changeset) => 0 === Object.keys(changeset.packages).length);
+        const bundled = await findBundledPinChanges(changed, changesetsInDiff, packages, config);
+        const missingChangesets = hasEmptyChangeset
+            ? []
+            : changedPackages.filter((name) => !hasChangeset(changesetsInDiff, name) &&
+                !bundled.has(name));
+        // A pin that doesn't resolve the local package selects a registry release
+        // instead, which the dependents policy won't re-release automatically.
+        const warnings = config.dependents
+            ? await collectPinDriftWarnings(config, packages)
+            : [];
+        return {
+            changesets,
+            releases,
+            changedPackages,
+            changedPackageFiles: changed.filesByPackage,
+            missingChangesets,
+            warnings,
+        };
+    }
+    /**
+     * Write the versions, dependency specs and changelogs of the releases and
+     * consume the applied changesets, restoring every changed file when a
+     * step fails.
+     *
+     * @param context  Release context.
+     * @param plan     Selected release plan.
+     * @param releases Releases with their changelog entries.
+     * @param date     Release date, as YYYY-MM-DD.
+     * @param applied  Versioned packages, or undefined when all were versioned.
+     */
+    async writeReleases(context, plan, releases, date, applied) {
+        const journal = new FileJournal();
+        const changesetDirectory = this.getChangesetDirectory(context.config);
         try {
             for (const release of releases) {
-                const configured = packages.find((pkg) => pkg.name === release.package.name);
-                if (!configured) {
-                    throw new ValidationError(`Unknown package "${release.package.name}".`);
-                }
-                for (const target of configured.versionConfig.to) {
-                    await writeVersion(configured.directory, target, release.nextVersion, journal);
-                }
-                for (const sourceName of release.sources ?? []) {
-                    const source = releasePlan.releases.find((item) => item.package.name === sourceName);
-                    if (!source) {
-                        throw new ValidationError(`The dependent package "${release.package.name}" bundles unreleased package "${sourceName}".`);
-                    }
-                    await updateDependencyDeclaration({
-                        dependent: release.package,
-                        source: source.package,
-                        version: source.nextVersion,
-                        rule: config.dependents,
-                        journal,
-                    });
-                }
-                await verifyVersionTargets(input.cwd, configured, release.nextVersion);
-                await prependChangelog(configured.directory, release, date, config.readmeChangelog ?? false, config.changelogInsertAfter, journal);
+                await this.writeRelease(context, plan, release, date, journal);
             }
-            for (const changeset of releasePlan.changesets) {
-                await consumeChangeset(path.join(changesetDirectory, changeset.fileName), changeset, input.packages, journal);
+            for (const changeset of plan.changesets) {
+                await consumeChangeset(path.join(changesetDirectory, changeset.fileName), changeset, applied, journal);
             }
         }
         catch (error) {
-            const rollbackErrors = await restoreFileJournal(journal);
+            const rollbackErrors = await journal.restore();
             if (rollbackErrors.length) {
                 throw new AggregateError([error, ...rollbackErrors], 'Changeset versioning failed and one or more file changes could not be rolled back.');
             }
             throw error;
         }
     }
-    return {
-        changesets: releasePlan.changesets,
-        releases,
-        date,
-        changed: !input.dryRun &&
-            (releasePlan.changesets.length > 0 ||
-                releasePlan.releases.length > 0),
-    };
-}
-/**
- * Drop bundle sources that aren't released by the selected plan.
- *
- * @param plan Selected release plan.
- * @return Release plan with dependents bundling only its released sources.
- */
-function expandDependentsPlan(plan) {
-    const released = new Set(plan.releases.map((release) => release.package.name));
-    plan.releases.forEach((release) => {
-        if (release.sources) {
-            release.sources = release.sources.filter((name) => released.has(name));
-            if (!release.sources.length) {
-                delete release.sources;
-            }
-        }
-    });
-    return plan;
-}
-/**
- * Remove the derived dependent releases of a plan, keeping only the releases
- * of packages that have their own changesets.
- *
- * @param plan Release plan of all pending changesets.
- * @return Release plan without derived dependent releases.
- */
-function stripDependentsPlan(plan) {
-    return {
-        ...plan,
-        releases: plan.releases
-            .filter((release) => release.changesets.length > 0)
-            .map(({ sources, ...release }) => release),
-    };
-}
-/**
- * Fail when a planned release bundles a source package that has pending
- * changesets released by a later run, so that no dependent ships unreleased
- * code under a changelog that cannot credit it.
- *
- * @param  plan     Planned releases.
- * @param  fullPlan Release plan of all pending changesets.
- * @param  packages Discovered packages.
- * @param  config   Repository release configuration.
- * @throws {ValidationError} If a source of a planned release stays pending.
- */
-async function assertDependentsSourcesReleased(plan, fullPlan, packages, config) {
-    const releasing = new Set(plan.releases.map((release) => release.package.name));
-    const pending = new Set(fullPlan.releases.map((release) => release.package.name));
-    for (const release of plan.releases) {
-        // Dependencies built into the dependent, like bundled or vendored
-        // directories, stay out of the check, which only guards released
-        // packages that the dependent declares.
-        const names = await collectDependencyNames(release.package, packages, config);
-        for (const name of names) {
-            const blocked = pending.has(name) &&
-                !releasing.has(name) &&
-                name !== release.package.name;
-            if (blocked) {
-                throw new ValidationError(`Cannot release package "${release.package.name}" while its source "${name}" has pending changesets; release them together or pass --no-dependents.`);
-            }
-        }
-    }
-}
-/**
- * Collect the names of the configured sources that a package declares, by the
- * dependency sections of the policy, without resolving the specs against the
- * versions. The changeset check uses this to see through a pin that the
- * versioning will rewrite after the source releases.
- *
- * @param pkg      Planned package.
- * @param packages Discovered packages.
- * @param config   Repository release configuration.
- * @return Release package names the package declares.
- */
-async function collectDeclarationNames(pkg, packages, config) {
-    const names = [];
-    for (const source of packages) {
-        if (pkg.name !== source.name &&
-            (await findNpmSpecs(pkg, source, dependentsSections(config.dependents))).length > 0) {
-            names.push(source.name);
-        }
-    }
-    return names;
-}
-/**
- * Collect the names of the configured sources that a package builds against,
- * through specs that resolve the current version or point at the workspace.
- *
- * @param pkg      Planned package.
- * @param packages Discovered packages.
- * @param config   Repository release configuration.
- * @return Release package names the package declares.
- */
-async function collectDependencyNames(pkg, packages, config) {
-    const names = [];
-    for (const source of packages) {
-        if (pkg.name !== source.name &&
-            (await findDependencySpecs(pkg, source, config.dependents))
-                .length > 0) {
-            names.push(source.name);
-        }
-    }
-    return names;
-}
-/**
- * Update how a dependent declares its dependency on a released source, with
- * the configured hook or the built-in spec rewrite.
- *
- * @param input           Dependent, source, released version, policy and journal.
- * @param input.dependent The released dependent package.
- * @param input.source    Released source package that the dependent bundles.
- * @param input.version   Released version of the source.
- * @param input.rule      Dependents policy with its sections and dependency hooks.
- * @param input.journal   File journal for rolling back.
- */
-async function updateDependencyDeclaration(input) {
-    const { dependent, source, version, rule, journal } = input;
-    const specs = await findDependencySpecs(dependent, source, rule);
-    const update = rule?.dependency?.update;
-    if (update) {
-        await update({
-            package: dependent,
-            source,
-            version,
-            specs,
-            remember: (file) => rememberFile(journal, file),
-        });
-        return;
-    }
-    for (const { file, name, spec } of specs) {
-        const nextSpec = updatedSpec(spec, version);
-        if (null === nextSpec &&
-            isOutOfRange(version, spec, source.currentVersion)) {
-            throw new ValidationError(`Cannot rewrite the dependency spec "${spec}" of "${name}" in ${dependent.name}'s ${file}; declare a range or pin that versioning rewrites, like "^${version}".`);
-        }
-        const changed = undefined !== nextSpec && nextSpec !== spec;
-        if (changed) {
-            const contents = await readFile(file, 'utf8');
-            const declared = new RegExp(`"${escapeRegExp(name)}"\\s*:\\s*"${escapeRegExp(spec)}"`);
-            if (!declared.test(contents)) {
-                throw new ValidationError(`The dependency spec of "${name}" in ${dependent.name}'s ${file} doesn't match "${spec}"; rewrite it to "${nextSpec}".`);
-            }
-            await rememberFile(journal, file);
-            await writeFile(file, contents.replace(declared, `"${name}": "${nextSpec}"`));
+    /**
+     * Write the version, the dependency specs of bundled sources and the
+     * changelog of a release.
+     *
+     * @param context Release context.
+     * @param plan    Selected release plan.
+     * @param release Release with its changelog entries.
+     * @param date    Release date, as YYYY-MM-DD.
+     * @param journal File journal for rolling back.
+     */
+    async writeRelease(context, plan, release, date, journal) {
+        const { config } = context;
+        const configured = context.packages.find((pkg) => pkg.name === release.package.name);
+        if (!configured) {
+            throw new ValidationError(`Unknown package "${release.package.name}".`);
         }
-    }
-}
-/**
- * Update a dependency spec to the released version, keeping its shape, like
- * the caret of ^0.9.0 or the x of 0.9.x.
- *
- * @param spec    Declared spec of the source.
- * @param version Released version of the source.
- * @return The updated spec, undefined when nothing has to change, like a wildcard or a workspace spec, or null when the spec can't be rewritten.
- */
-function updatedSpec(spec, version) {
-    if (spec.startsWith('workspace:')) {
-        // Workspace specs resolve to the local package, so the manifest
-        // keeps them instead of a published version.
-        return undefined;
-    }
-    const prefix = /^[=\^~]/.exec(spec)?.[0] ?? '';
-    const bare = spec.slice(prefix.length).trim();
-    const partial = /^(v?\d+(?:\.\d+)*)(\.x)?$/.exec(bare);
-    if (partial?.[1]) {
-        const depth = partial[1].split('.').length;
-        const stem = version.split('.').slice(0, depth).join('.');
-        // npm partials like 1.x pin the major, and 0.9 pins the major.minor.
-        return `${prefix}${stem}${partial[2] ?? ''}`;
-    }
-    // Wildcards and keyword specs like * or latest already accept the release.
-    return null;
-}
-/**
- * Format the changelog entries of each release, with the configured
- * formatter and the commit that added each changeset.
- *
- * @param cwd                Repository root.
- * @param config             Repository release configuration.
- * @param releases           Package releases.
- * @param changesetDirectory Directory of the changeset files.
- * @return Releases with their changelog entries.
- */
-async function getVersionedReleases(cwd, config, releases, changesetDirectory) {
-    const commits = new Map();
-    const getCommit = (changeset) => {
-        const cached = commits.get(changeset.fileName) ??
-            getChangesetCommit(cwd, path.join(changesetDirectory, changeset.fileName));
-        commits.set(changeset.fileName, cached);
-        return cached;
-    };
-    const releasesByName = new Map(releases.map((release) => [release.package.name, release]));
-    return Promise.all(releases.map(async (release) => {
-        const entries = [];
-        // Format one at a time, so that formatters calling an API aren't rate limited.
-        for (const changeset of release.changesets) {
-            entries.push(await getChangelogEntry(config, release.package, changeset, getCommit));
+        for (const target of configured.versionConfig.to) {
+            await writeVersion(configured.directory, target, release.nextVersion, journal);
         }
         for (const sourceName of release.sources ?? []) {
-            const source = releasesByName.get(sourceName);
+            const source = plan.releases.find((item) => item.package.name === sourceName);
             if (!source) {
                 throw new ValidationError(`The dependent package "${release.package.name}" bundles unreleased package "${sourceName}".`);
             }
-            entries.push(await getDependentsChangelogEntry(config, release.package, source));
+            await updateDependencyDeclaration({
+                dependent: release.package,
+                source: source.package,
+                version: source.nextVersion,
+                rule: config.dependents,
+                journal,
+            });
         }
-        return { ...release, changelog: formatChangelogList(entries) };
-    }));
-}
-/**
- * Format the bundle changelog entry of a dependent release.
- *
- * @param config Repository release configuration.
- * @param pkg    Dependent package being re-released.
- * @param source Released source package bundled by the dependent.
- * @return Changelog entry.
- */
-async function getDependentsChangelogEntry(config, pkg, source) {
-    if (!config.dependents?.changelog) {
-        return `Bundle ${source.package.name.split('/').pop()} ${source.nextVersion}.`;
-    }
-    const entry = await config.dependents.changelog({
-        package: pkg,
-        source: {
-            package: source.package,
-            version: source.nextVersion,
-        },
-    });
-    if ('string' !== typeof entry) {
-        throw new ValidationError(`The dependents changelog formatter didn't return a string for package "${pkg.name}".`);
-    }
-    return entry.trim();
-}
-async function getChangelogEntry(config, pkg, changeset, getCommit) {
-    const summary = changeset.summary.trim();
-    if (!summary || !config.changelogEntry) {
-        return summary;
-    }
-    const commit = await getCommit(changeset);
-    const entry = await config.changelogEntry({
-        package: pkg,
-        changeset,
-        ...(commit ? { commit } : {}),
-    });
-    if ('string' !== typeof entry) {
-        throw new ValidationError(`The changelogEntry formatter didn't return a string for changeset ${changeset.fileName}.`);
-    }
-    return entry.trim();
-}
-/**
- * Find the commit that added a changeset file.
- *
- * @param cwd  Repository root.
- * @param file Changeset file.
- * @return Commit, or undefined when the file isn't committed.
- */
-async function getChangesetCommit(cwd, file) {
-    const output = await git(cwd, [
-        'log',
-        '--diff-filter=A',
-        '--format=%H%x1f%h%x1f%s',
-        '-1',
-        '--',
-        path.relative(cwd, file).split(path.sep).join('/'),
-    ]);
-    const [hash, shortHash = '', subject = ''] = output
-        .trim()
-        .split('\x1f');
-    return hash ? { hash, shortHash, subject } : undefined;
-}
-/**
- * Add a package to the selected release plan when it bundles a selected source.
- *
- * @param source    Selected package release.
- * @param dependent Package that would bundle the source.
- * @param packages  Discovered packages.
- * @param rule      Dependents policy.
- * @param selected  Selected package names, mutated in place.
- * @return Whether the package was selected.
- */
-async function selectDependentRelease(source, dependent, packages, rule, selected) {
-    const skip = selected.has(dependent.name) ||
-        dependent.name === source.package.name ||
-        isExcludedDependent(dependent, rule);
-    if (skip) {
-        return false;
-    }
-    const specs = await findDependencySpecs(dependent, source.package, rule);
-    if (!specs.length || !dependentNeedsRelease(specs, source, rule)) {
-        return false;
-    }
-    selected.add(dependent.name);
-    return true;
-}
-/**
- * Limit a release plan to some packages and the changesets that name them.
- *
- * @param  plan           Release plan of all pending changesets.
- * @param  packages       Configured packages.
- * @param  names          Packages to version.
- * @param  config         Repository release configuration.
- * @param  withDependents Whether the selection also releases the dependents of the selected sources.
- * @return Release plan of the selected packages and their dependents.
- * @throws {ValidationError} For unknown packages.
- */
-async function selectReleasePlan(plan, packages, names, config, withDependents = true) {
-    names.forEach((name) => {
-        if (!packages.some((pkg) => pkg.name === name)) {
-            throw new ValidationError(`Unknown package "${name}".`);
+        await verifyVersionTargets(this.repository, configured, release.nextVersion);
+        await prependChangelog(configured.directory, release, date, config.readmeChangelog ?? false, config.changelogInsertAfter, journal);
+    }
+    /**
+     * Load the configuration, discover the packages and plan the releases of
+     * the pending changesets, including the releases of their dependents.
+     *
+     * @return Release context, undefined without a config.
+     * @throws {ValidationError} For an invalid config, plan or changeset.
+     */
+    async loadContext() {
+        const loaded = await loadChangesetConfig({
+            cwd: this.cwd,
+            ...(this.configFile ? { configFile: this.configFile } : {}),
+        });
+        if (!loaded) {
+            return undefined;
         }
-    });
-    // Dependents that need a release close over the selected sources.
-    const selected = new Set(names);
-    let grew = true;
-    // Dependents may depend on other selected dependents, so expand until stable.
-    while (grew && withDependents && config.dependents) {
-        grew = false;
-        const selectedSources = plan.releases.filter((release) => selected.has(release.package.name));
-        for (const source of selectedSources) {
-            for (const dependent of packages) {
-                if (await selectDependentRelease(source, dependent, packages, config.dependents, selected)) {
-                    grew = true;
+        const config = loaded.config;
+        const packages = await discoverPackages(this.repository, config);
+        const changesets = await readChangesets(this.getChangesetDirectory(config));
+        const releases = [];
+        packages.forEach((pkg) => {
+            const bump = getChangesetBump(changesets, pkg.name);
+            if (bump) {
+                const packageChangesets = changesets.filter((changeset) => Object.hasOwn(changeset.packages, pkg.name));
+                const nextVersion = config.nextVersion
+                    ? config.nextVersion({
+                        package: pkg,
+                        bump,
+                        currentVersion: pkg.currentVersion,
+                        changesets: packageChangesets,
+                    })
+                    : getNextVersion(pkg.currentVersion, bump);
+                if ('string' !== typeof nextVersion || !nextVersion.trim()) {
+                    throw new ValidationError(`The nextVersion strategy returned an empty version for package "${pkg.name}".`);
                 }
+                releases.push({
+                    package: pkg,
+                    bump,
+                    currentVersion: pkg.currentVersion,
+                    nextVersion,
+                    changesets: packageChangesets,
+                });
             }
-        }
-    }
-    const selectedNames = [...selected];
-    return {
-        releases: plan.releases.filter((release) => {
-            if (!selected.has(release.package.name)) {
-                return false;
-            }
-            // Explicitly selected dependents without their own changesets only
-            // release when their source releases in the same selection.
-            return (release.changesets.length > 0 ||
-                (release.sources ?? []).some((name) => selected.has(name)));
-        }),
-        changesets: plan.changesets.filter((changeset) => selectedNames.some((name) => Object.hasOwn(changeset.packages, name))),
-    };
-}
-/**
- * Remove an applied changeset, or only the applied packages from a changeset
- * that names other packages too, so that their releases keep its summary.
- *
- * @param file      Changeset file.
- * @param changeset Parsed changeset.
- * @param applied   Versioned packages, or undefined when all were versioned.
- * @param journal   File journal for rolling back.
- */
-async function consumeChangeset(file, changeset, applied, journal) {
-    const remaining = Object.entries(changeset.packages).filter(([name]) => undefined !== applied && !applied.includes(name));
-    await rememberFile(journal, file);
-    if (remaining.length) {
-        await writeFile(file, formatChangeset({
-            packages: Object.fromEntries(remaining),
-            summary: changeset.summary,
-        }));
-    }
-    else {
-        await rm(file);
-    }
-}
-/**
- * Create missing release tags, optionally pushing them to the configured remote.
- *
- * @param input Repository and tag options.
- * @return Per-package tags and release notes.
- */
-export async function tagChangesets(input) {
-    if (input.githubRelease && !input.push) {
-        throw new ValidationError('GitHub Releases require pushing the tags.');
-    }
-    if (input.untagged && input.push) {
-        throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
-    }
-    const context = await getReleaseContext(input);
-    if (!context) {
-        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
-    }
-    const selected = selectPackages(context.packages, input);
-    const packages = input.since
-        ? (await changedPackagesSince(input.cwd, selected, input.since))
-            .packages
-        : selected;
-    const results = [];
-    const dryRun = input.dryRun || input.untagged;
-    const tagFormat = context.config.tagFormat ?? '{path}/{version}';
-    for (const pkg of packages) {
-        const version = await getTagVersion(pkg, input.version);
-        if (undefined !== input.version && input.version !== version) {
-            throw new ValidationError(`Package "${pkg.name}" is at version ${version}, not ${input.version}.`);
-        }
-        const tag = formatTag(tagFormat, pkg, version);
-        const exists = await gitTagExists(input.cwd, tag);
-        if (!exists) {
-            await verifyVersionTargets(input.cwd, pkg, version);
-        }
-        const previousTag = await getPreviousTag(input.cwd, formatTag(tagFormat, pkg, ''), version);
-        const notes = await getReleaseNotes(input.cwd, context.config, pkg, { version, tag, previousTag }, exists ? tag : 'HEAD');
-        if (!exists && !dryRun) {
-            await git(input.cwd, ['tag', tag]);
-        }
-        results.push({
-            package: pkg.name,
-            version,
-            tag,
-            ...(previousTag ? { previousTag } : {}),
-            prerelease: isPrerelease(version),
-            exists,
-            created: !exists && !dryRun,
-            notes,
         });
-    }
-    // Push one tag at a time because GitHub doesn't create push events for
-    // tags when more than three are pushed at once.
-    if (input.push && !dryRun) {
-        for (const item of results.filter((result) => result.created)) {
-            await git(input.cwd, ['push', 'origin', item.tag]);
-        }
-    }
-    if (input.githubRelease && !dryRun) {
-        for (const release of results) {
-            await createGitHubRelease(input.cwd, release);
-        }
-    }
-    return {
-        tags: input.untagged
-            ? results.filter((result) => !result.exists)
-            : results,
-    };
-}
-async function createGitHubRelease(cwd, release) {
-    try {
-        await execFileAsync('gh', ['release', 'view', release.tag], {
-            cwd,
+        changesets.forEach((changeset) => {
+            Object.keys(changeset.packages).forEach((name) => {
+                if (!packages.some((pkg) => pkg.name === name)) {
+                    throw new ValidationError(`Changeset ${changeset.fileName} refers to unknown package "${name}".`);
+                }
+            });
         });
-    }
-    catch {
-        try {
-            await execFileAsync('gh', [
-                'release',
-                'create',
-                release.tag,
-                '--title',
-                `${release.package}@${release.version}`,
-                '--notes',
-                release.notes,
-                ...(release.prerelease ? ['--prerelease'] : []),
-            ], { cwd });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new ValidationError(`Could not create GitHub Release for ${release.tag}: ${message}`);
+        await applyDependents(releases, packages, config);
+        return { config, packages, plan: { changesets, releases } };
+    }
+    /**
+     * Load the release context of a repository that has to be configured.
+     *
+     * @return Release context.
+     * @throws {ValidationError} Without a config.
+     */
+    async requireContext() {
+        const context = await this.loadContext();
+        if (!context) {
+            throw new ValidationError(MISSING_CONFIG);
+        }
+        return context;
+    }
+    /**
+     * Load the configuration of a repository that has to be configured.
+     *
+     * @return Repository release configuration.
+     * @throws {ValidationError} Without a config.
+     */
+    async requireConfig() {
+        const loaded = await loadChangesetConfig({
+            cwd: this.cwd,
+            ...(this.configFile ? { configFile: this.configFile } : {}),
+        });
+        if (!loaded) {
+            throw new ValidationError(MISSING_CONFIG);
         }
+        return loaded.config;
     }
-}
-/**
- * Get the version to tag. Packages versioned by their git tags have no
- * version file, so the expected version is the version to tag, or else the
- * latest CHANGELOG.md version.
- *
- * @param pkg      Configured package.
- * @param expected Expected version from --version, if any.
- * @return Version to tag.
- */
-async function getTagVersion(pkg, expected) {
-    if ('git-tag' !== pkg.versionConfig.from.kind) {
-        return pkg.currentVersion;
+    /**
+     * Get the directory of the changeset files.
+     *
+     * @param config Repository release configuration.
+     * @return Absolute directory path.
+     */
+    getChangesetDirectory(config) {
+        return path.resolve(this.cwd, config.changesets ?? '.changeset');
     }
-    return (expected ??
-        (await getLatestChangelogVersion(pkg.directory, pkg.currentVersion)));
 }
 /**
- * Pick the packages passed with --package, or all packages without it.
+ * Discover configured packages, pending changesets, and their proposed versions.
  *
- * @param  packages Configured packages.
- * @param  input    Tag options.
- * @return Selected packages in the configured order.
- * @throws {ValidationError} For unknown packages, or --version without a single package.
+ * @param input Repository root and optional explicit config file.
+ * @return A release plan; `undefined` when no config is present.
  */
-function selectPackages(packages, input) {
-    const names = input.packages ?? [];
-    if (undefined !== input.version && 1 !== names.length) {
-        throw new ValidationError('An expected version requires exactly one package.');
-    }
-    names.forEach((name) => {
-        if (!packages.some((pkg) => pkg.name === name)) {
-            throw new ValidationError(`Unknown package "${name}".`);
-        }
-    });
-    return names.length
-        ? packages.filter((pkg) => names.includes(pkg.name))
-        : packages;
+export async function getChangesetReleasePlan(input) {
+    return new ChangesetRelease(input).getPlan();
 }
 /**
- * Find the tag of the newest release before a version.
+ * Discover the packages of the repository configuration.
  *
- * @param cwd     Repository root.
- * @param prefix  Tag prefix of the package, like `plugins/alpha/`.
- * @param version Version being released.
- * @return Previous tag, or undefined for the first release.
+ * @param  input Repository root and optional explicit config file.
+ * @return Packages in the configured order with their current versions.
+ * @throws {ValidationError} Without a config, or for an invalid one.
  */
-async function getPreviousTag(cwd, prefix, version) {
-    const output = await git(cwd, ['tag', '--list', `${prefix}*`]);
-    return output
-        .trim()
-        .split(/\r?\n/)
-        .filter((tag) => tag.startsWith(prefix))
-        .map((tag) => ({ tag, version: tag.slice(prefix.length) }))
-        .filter((item) => isVersion(item.version) &&
-        compareVersions(item.version, version) < 0)
-        .sort((a, b) => compareVersions(b.version, a.version))[0]?.tag;
+export async function getChangesetPackages(input) {
+    return new ChangesetRelease(input).getPackages();
 }
 /**
- * Build the release notes of a tag with the configured formatter.
+ * Create a Changesets-compatible Markdown file.
  *
- * @param cwd                 Repository root.
- * @param config              Repository release configuration.
- * @param pkg                 Released package.
- * @param release             Version, tag and previous tag of the release.
- * @param release.version     Released version.
- * @param release.tag         Release tag.
- * @param release.previousTag Tag of the previous release, if any.
- * @param end                 Commit of the release: the tag, or HEAD before tagging.
- * @return Release notes.
+ * @param input Repository, packages and summary.
+ * @return Created file path.
  */
-async function getReleaseNotes(cwd, config, pkg, release, end) {
-    const changelog = await readReleaseNotes(pkg.directory, release.version);
-    const commits = await getReleaseCommits(cwd, pkg, end, release.previousTag);
-    const notes = changelog ||
-        commits
-            .map((commit) => `- ${commit.subject} (${commit.shortHash})`)
-            .join('\n');
-    if (!config.releaseNotes) {
-        return notes;
-    }
-    const formatted = await config.releaseNotes({
-        package: toChangesetPackage(pkg),
-        ...release,
-        changelog,
-        commits,
-        notes,
-    });
-    if ('string' !== typeof formatted) {
-        throw new ValidationError(`The releaseNotes formatter didn't return a string for package "${pkg.name}".`);
-    }
-    return formatted.trim();
+export async function addChangeset(input) {
+    return new ChangesetRelease(input).add(input);
 }
 /**
- * List the commits that changed a package since its previous release.
+ * Apply pending package versions and changelogs.
  *
- * @param cwd         Repository root.
- * @param pkg         Released package.
- * @param end         Commit of the release.
- * @param previousTag Tag of the previous release, if any.
- * @return Commits, newest first.
+ * @param input Repository and versioning options.
+ * @return Planned releases and whether files were changed.
  */
-async function getReleaseCommits(cwd, pkg, end, previousTag) {
-    const packageFromRepo = path.relative(cwd, pkg.directory).split(path.sep).join('/') ||
-        '.';
-    const output = await git(cwd, [
-        'log',
-        '--format=%H%x1f%h%x1f%s',
-        previousTag ? `${previousTag}..${end}` : end,
-        '--',
-        packageFromRepo,
-    ]);
-    return output
-        .trim()
-        .split(/\r?\n/)
-        .filter(Boolean)
-        .map((line) => {
-        const [hash = '', shortHash = '', subject = ''] = line.split('\x1f');
-        return { hash, shortHash, subject };
-    });
+export async function versionChangesets(input) {
+    return new ChangesetRelease(input).version(input);
 }
 /**
- * Remove the release configuration from a package passed to config callbacks.
+ * Create missing release tags, optionally pushing them to the configured remote.
  *
- * @param pkg Configured package.
- * @return Package without its group configuration.
+ * @param input Repository and tag options.
+ * @return Per-package tags and release notes.
  */
-function toChangesetPackage(pkg) {
-    return {
-        name: pkg.name,
-        directory: pkg.directory,
-        path: pkg.path,
-        type: pkg.type,
-        currentVersion: pkg.currentVersion,
-    };
+export async function tagChangesets(input) {
+    return new ChangesetRelease(input).tag(input);
 }
 /**
  * Check whether changed files belong to packages without a changeset.
@@ -1019,733 +421,5 @@ function toChangesetPackage(pkg) {
  * @return Changed packages and missing changeset identifiers.
  */
 export async function getChangesetStatus(input) {
-    const context = await getReleaseContext(input);
-    if (!context) {
-        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
-    }
-    const { plan } = context;
-    const { changesets, releases } = plan;
-    const config = context.config;
-    const { packages } = context;
-    const since = input.since ??
-        (context.config.baseBranch
-            ? `origin/${context.config.baseBranch}`
-            : undefined);
-    const changed = since
-        ? await changedPackagesSince(input.cwd, context.packages, since)
-        : { packages: [], filesByPackage: {} };
-    const changedPackages = changed.packages.map((pkg) => pkg.name);
-    const changesetsInDiff = since
-        ? await readChangesetsSince(input.cwd, context.config, changesets, since)
-        : [];
-    const hasEmptyChangeset = changesetsInDiff.some((changeset) => 0 === Object.keys(changeset.packages).length);
-    // A dependent releases with its sources, which the release pull request
-    // already announces when this pull request's changesets release one of
-    // them. Exempting its package manifest pin change keeps the check from
-    // demanding an entry for what versioning rewrites anyway; documentation
-    // and code changes still need their own changesets.
-    const bundled = new Set((await Promise.all(changedPackages
-        .filter((name) => !changesetsInDiff.some((item) => Object.hasOwn(item.packages, name)))
-        .map(async (name) => {
-        if (!config.dependents ||
-            !(changed.filesByPackage[name] ?? []).every((file) => path.basename(file) === 'package.json')) {
-            return undefined;
-        }
-        const configured = packages.find((pkg) => pkg.name === name);
-        if (!configured) {
-            return undefined;
-        }
-        const sources = await collectDeclarationNames(configured, packages, config);
-        return changesetsInDiff.some((item) => sources.some((source) => Object.hasOwn(item.packages, source)))
-            ? name
-            : undefined;
-    }))).filter((name) => undefined !== name));
-    const missingChangesets = hasEmptyChangeset
-        ? []
-        : changedPackages.filter((name) => !changesetsInDiff.some((item) => Object.hasOwn(item.packages, name)) && !bundled.has(name));
-    // A pin that doesn't resolve the local package selects a registry release
-    // instead, which the dependents policy won't re-release automatically.
-    const warnings = config.dependents
-        ? await collectPinDriftWarnings(context.config, context.packages)
-        : [];
-    return {
-        changesets,
-        releases,
-        changedPackages,
-        changedPackageFiles: changed.filesByPackage,
-        missingChangesets,
-        warnings,
-    };
-}
-/**
- * Warn about declared pins of configured packages that don't resolve the
- * current version of the package they name.
- *
- * @param config   Repository release configuration.
- * @param packages Discovered packages.
- * @return Warnings, one per package pair.
- */
-async function collectPinDriftWarnings(config, packages) {
-    const warnings = [];
-    for (const dependent of packages) {
-        const others = packages.filter((source) => source.name !== dependent.name);
-        for (const source of others) {
-            const driftedPin = (await findNpmSpecs(dependent, source, config.dependents?.sections ?? DEFAULT_SECTIONS))
-                .filter(({ spec }) => !spec.startsWith('workspace:') &&
-                isOutOfRange(source.currentVersion, spec, source.currentVersion))
-                .at(0);
-            if (driftedPin) {
-                warnings.push(`"${dependent.name}" pins "${driftedPin.name}@${driftedPin.spec}", but the package is at ${source.currentVersion}; the dependents policy won't re-release it until the pin resolves the package.`);
-            }
-        }
-    }
-    return warnings;
-}
-/**
- * Find the npm specs that a package declares for a source, without the
- * dependency filtering of dependents links, for drift warnings.
- *
- * @param dependent Package potentially declaring the dependency.
- * @param source    Package the dependency is declared of.
- * @param sections  Dependency sections to scan.
- * @return The declared specs.
- */
-async function findNpmSpecs(dependent, source, sections) {
-    const sourceManifest = await readJsonSafe(path.join(source.directory, 'package.json'));
-    if ('string' !== typeof sourceManifest?.name) {
-        return [];
-    }
-    const identifier = sourceManifest.name;
-    const parsed = await readJsonSafe(path.join(dependent.directory, 'package.json'));
-    const specs = [];
-    for (const section of sections) {
-        const sectionSpecs = parsed?.[section];
-        const declared = 'object' === typeof sectionSpecs &&
-            null !== sectionSpecs &&
-            Object.hasOwn(sectionSpecs, identifier)
-            ? String(sectionSpecs[identifier])
-            : undefined;
-        if (undefined !== declared) {
-            specs.push({
-                file: path.join(dependent.directory, 'package.json'),
-                name: identifier,
-                spec: declared,
-            });
-        }
-    }
-    return specs;
-}
-async function requireConfig(input) {
-    const loaded = await loadChangesetConfig(input);
-    if (!loaded) {
-        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
-    }
-    return loaded;
-}
-async function readChangesets(cwd, config) {
-    const directory = path.resolve(cwd, config.changesets ?? '.changeset');
-    let entries;
-    try {
-        entries = await readdir(directory);
-    }
-    catch (error) {
-        if ('ENOENT' === error.code) {
-            return [];
-        }
-        throw error;
-    }
-    return Promise.all(entries
-        .filter((name) => name.endsWith('.md') && !name.startsWith('README'))
-        .sort()
-        .map(async (name) => parseChangeset(await readFile(path.join(directory, name), 'utf8'), name)));
-}
-async function readChangesetsSince(cwd, config, changesets, since) {
-    const directory = path.resolve(cwd, config.changesets ?? '.changeset');
-    const relativeDirectory = path
-        .relative(cwd, directory)
-        .split(path.sep)
-        .join('/');
-    const output = await git(cwd, [
-        'diff',
-        '--name-only',
-        '--diff-filter=ACMR',
-        `${since}...HEAD`,
-        '--',
-        relativeDirectory,
-    ]);
-    const changedFiles = new Set(output.trim().split(/\r?\n/).filter(Boolean));
-    return changesets.filter((changeset) => changedFiles.has(path.posix.join(relativeDirectory, changeset.fileName)));
-}
-async function discoverPackages(cwd, config) {
-    const root = path.resolve(cwd, config.root ?? '.');
-    const packages = [];
-    const hasRecursiveGlob = config.packages.some((item) => item.glob.split('/').includes('**'));
-    const directories = await findDirectories(root, '', hasRecursiveGlob
-        ? Infinity
-        : Math.max(1, ...config.packages.map((item) => item.glob.split('/').length + 2)));
-    for (const group of config.packages) {
-        const matcher = globRegExp(group.glob);
-        const candidates = matcher.test('.')
-            ? ['.', ...directories]
-            : directories;
-        const matches = candidates
-            .filter((item) => matcher.test(item) &&
-            !(group.exclude ?? []).some((excluded) => globRegExp(excluded).test(item)))
-            .sort();
-        if (!matches.length) {
-            throw new ValidationError(`Package glob "${group.glob}" did not match any directories under ${root}.`);
-        }
-        for (const relativePath of matches) {
-            const directory = path.join(root, relativePath);
-            const name = await packageName(directory, relativePath, group.idFrom ?? 'path');
-            const currentVersion = await readVersion(cwd, directory, group.version.from, relativePath, group.tagType);
-            if (packages.some((pkg) => pkg.name === name)) {
-                throw new ValidationError(`Package identifier "${name}" is configured more than once.`);
-            }
-            packages.push({
-                name,
-                directory,
-                path: relativePath,
-                type: packageType(group),
-                currentVersion,
-                group,
-                versionConfig: group.version,
-            });
-        }
-    }
-    return packages;
-}
-async function findDirectories(root, prefix = '', maxDepth = 5) {
-    let entries;
-    try {
-        entries = await readdir(path.join(root, prefix), {
-            withFileTypes: true,
-        });
-    }
-    catch (error) {
-        if ('ENOENT' === error.code) {
-            return [];
-        }
-        throw error;
-    }
-    const directories = entries.filter((item) => item.isDirectory() &&
-        !['.git', 'node_modules', 'vendor', 'dist'].includes(item.name));
-    if (prefix.split(path.sep).filter(Boolean).length >= maxDepth) {
-        return directories.map((item) => path.join(prefix, item.name));
-    }
-    const children = await Promise.all(directories.map((item) => findDirectories(root, path.join(prefix, item.name), maxDepth)));
-    return [
-        ...directories.map((item) => path.join(prefix, item.name)),
-        ...children.flat(),
-    ];
-}
-function globRegExp(glob) {
-    const escaped = glob
-        .split('/')
-        .map((part) => {
-        if ('**' === part) {
-            return '.*';
-        }
-        return part
-            .replaceAll(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replaceAll('*', '[^/]*')
-            .replaceAll('?', '[^/]');
-    })
-        .join('/');
-    return new RegExp(`^${escaped}$`);
-}
-async function packageName(directory, relativePath, idFrom) {
-    if ('path' === idFrom) {
-        if ('.' === relativePath) {
-            return path.basename(directory);
-        }
-        return relativePath.split(path.sep).join('/');
-    }
-    const [file, field] = idFrom.split('#');
-    if (!file || !field) {
-        throw new ValidationError(`Invalid package identifier source "${idFrom}".`);
-    }
-    const manifest = await readJson(path.join(directory, file));
-    const name = manifest[field];
-    if ('string' !== typeof name || !name.trim()) {
-        throw new ValidationError(`Expected ${file}#${field} in ${directory}.`);
-    }
-    return name;
-}
-async function readVersion(cwd, directory, descriptor, relativePath, tagType) {
-    if ('package-json' === descriptor.kind ||
-        'composer-json' === descriptor.kind) {
-        const manifest = await readJson(path.join(directory, descriptor.file));
-        const version = manifest[descriptor.field];
-        if ('string' === typeof version && version.trim()) {
-            return version;
-        }
-        throw new ValidationError(`Missing ${descriptor.file}#${descriptor.field} in ${directory}.`);
-    }
-    if ('git-tag' === descriptor.kind) {
-        const pattern = descriptor.pattern ?? '{path}/{version}';
-        const tagsOutput = await git(cwd, [
-            'tag',
-            '--list',
-            `${formatTemplatePrefix(pattern, relativePath, tagType)}*`,
-        ]);
-        const tags = tagsOutput.trim().split(/\r?\n/).filter(Boolean);
-        const versions = tags
-            .map((tag) => tag.match(/(?:^|\/|v)(\d+\.\d+\.\d+)$/)?.[1])
-            .filter((item) => Boolean(item));
-        versions.sort((a, b) => compareVersions(b, a));
-        if (versions[0]) {
-            return versions[0];
-        }
-        throw new ValidationError(`No git tag matches ${pattern} for ${relativePath}.`);
-    }
-    if ('php-constant' === descriptor.kind) {
-        const file = path.join(directory, descriptor.file);
-        const contents = await readFile(file, 'utf8');
-        const versions = findConstantValues(contents, descriptor.constant);
-        if (versions[0]) {
-            return versions[0];
-        }
-        throw new ValidationError(`Missing PHP constant ${descriptor.constant} in ${file}.`);
-    }
-    const file = path.join(directory, await getVersionFile(directory, descriptor.kind, descriptor.file));
-    const contents = await readFile(file, 'utf8');
-    const label = 'wordpress-stable-tag' === descriptor.kind ? 'Stable tag' : 'Version';
-    const match = new RegExp(`^\\s*\\*?\\s*${label}:\\s*([^\\r\\n]+)`, 'im').exec(contents);
-    if (!match) {
-        throw new ValidationError(`Missing ${label} header in ${file}.`);
-    }
-    return match[1]?.trim() ?? '';
-}
-async function writeVersion(directory, descriptor, version, journal) {
-    if ('package-json' === descriptor.kind ||
-        'composer-json' === descriptor.kind) {
-        const file = path.join(directory, descriptor.file);
-        const contents = await readFile(file, 'utf8');
-        const manifest = JSON.parse(contents);
-        if ('composer-json' === descriptor.kind &&
-            descriptor.ifPresent &&
-            !Object.hasOwn(manifest, descriptor.field)) {
-            return;
-        }
-        manifest[descriptor.field] = version;
-        await rememberFile(journal, file);
-        await writeFile(file, `${JSON.stringify(manifest, null, '\t')}\n`);
-        return;
-    }
-    if ('php-constant' === descriptor.kind) {
-        const file = path.join(directory, descriptor.file);
-        const contents = await readFile(file, 'utf8');
-        const constant = escapeRegExp(descriptor.constant);
-        const definePattern = new RegExp(`(\\bdefine\\s*\\(\\s*(['"])${constant}\\2\\s*,\\s*)(['"])(.*?)\\3`, 'g');
-        const declarationPattern = new RegExp(`(\\bconst\\s+${constant}\\s*=\\s*)(['"])(.*?)\\2`, 'g');
-        const updated = contents
-            .replace(definePattern, (_match, prefix, _nameQuote, quote) => `${prefix}${quote}${version}${quote}`)
-            .replace(declarationPattern, (_match, prefix, quote) => `${prefix}${quote}${version}${quote}`);
-        if (updated === contents) {
-            throw new ValidationError(`Missing PHP constant ${descriptor.constant} in ${file}.`);
-        }
-        await rememberFile(journal, file);
-        await writeFile(file, updated);
-        return;
-    }
-    if ('wordpress-stable-tag' === descriptor.kind &&
-        descriptor.ifPresent &&
-        !(await versionFileExists(directory, descriptor.kind, descriptor.file))) {
-        return;
-    }
-    const file = path.join(directory, await getVersionFile(directory, descriptor.kind, descriptor.file));
-    const contents = await readFile(file, 'utf8');
-    const label = 'wordpress-stable-tag' === descriptor.kind ? 'Stable tag' : 'Version';
-    const expression = new RegExp(`(^\\s*\\*?\\s*${label}:\\s*)[^\\r\\n]+`, 'im');
-    if (!expression.test(contents)) {
-        throw new ValidationError(`Missing ${label} header in ${file}.`);
-    }
-    await rememberFile(journal, file);
-    await writeFile(file, contents.replace(expression, `$1${version}`));
-}
-async function getVersionFile(directory, kind, configuredFile) {
-    if (configuredFile) {
-        return configuredFile;
-    }
-    if ('wordpress-plugin-header' === kind) {
-        const file = await findMainPluginFile({ dir: directory });
-        if (file) {
-            return file;
-        }
-        throw new ValidationError(`Could not find a plugin header file in ${directory}.`);
-    }
-    if ('wordpress-stable-tag' === kind) {
-        for (const file of ['readme.txt', 'readme.md']) {
-            try {
-                await access(path.join(directory, file));
-                return file;
-            }
-            catch {
-                // Try the next WordPress readme filename.
-            }
-        }
-        throw new ValidationError(`Could not find readme.txt or readme.md in ${directory}.`);
-    }
-    return 'style.css';
-}
-async function versionFileExists(directory, kind, configuredFile) {
-    if (configuredFile) {
-        try {
-            await access(path.join(directory, configuredFile));
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    if ('wordpress-stable-tag' === kind) {
-        const files = await Promise.all(['readme.txt', 'readme.md'].map(async (file) => {
-            try {
-                await access(path.join(directory, file));
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }));
-        return files.some(Boolean);
-    }
-    return true;
-}
-async function prependChangelog(directory, release, date, readmeChangelog, changelogInsertAfter, journal) {
-    const summaries = release.changesets
-        .map((item) => item.summary.trim())
-        .filter(Boolean);
-    const section = `## ${release.nextVersion} (${date})\n\n${release.changelog}\n\n`;
-    const changelog = path.join(directory, 'CHANGELOG.md');
-    let previous = '';
-    try {
-        previous = await readFile(changelog, 'utf8');
-    }
-    catch (error) {
-        if ('ENOENT' !== error.code) {
-            throw error;
-        }
-    }
-    const releaseHeading = new RegExp(`^## ${escapeRegExp(release.nextVersion)} \\(`, 'm');
-    if (!releaseHeading.test(previous)) {
-        await rememberFile(journal, changelog);
-        if (undefined !== changelogInsertAfter) {
-            await writeFile(changelog, insertAfterMarker(previous, changelogInsertAfter, section, changelog));
-        }
-        else {
-            const versionHeading = /^##[ \t]+v?\d+(?:\.\d+){1,2}(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?(?:[ \t]+.*)?$/m.exec(previous);
-            const heading = /^#[ \t]+[^\r\n]+[ \t]*$/m.exec(previous);
-            const insertion = versionHeading ?? heading;
-            if (insertion) {
-                const before = previous
-                    .slice(0, insertion.index)
-                    .replace(/(?:\r?\n)*$/, '');
-                const after = previous.slice(insertion.index);
-                const prefix = before ? `${before}\n\n` : '';
-                await writeFile(changelog, `${prefix}${section}${after}`);
-            }
-            else {
-                await writeFile(changelog, `${section}${previous}`);
-            }
-        }
-    }
-    if (readmeChangelog) {
-        const readme = ['readme.txt', 'readme.md'].map((name) => path.join(directory, name));
-        let readmeUpdated = false;
-        let readmeFound = false;
-        let readmeMarkerFound = false;
-        let readmeAlreadyVersioned = false;
-        for (const file of readme) {
-            try {
-                const contents = await readFile(file, 'utf8');
-                readmeFound = true;
-                const defaultHeading = undefined === changelogInsertAfter
-                    ? /^==\s*Changelog\s*==\s*$/im.exec(contents)?.[0]
-                    : undefined;
-                const insertionMarker = changelogInsertAfter ?? defaultHeading;
-                readmeMarkerFound ||=
-                    undefined !== insertionMarker &&
-                        contents.includes(insertionMarker);
-                const alreadyVersioned = new RegExp(`^=\\s*${escapeRegExp(release.nextVersion)}\\s*=$`, 'm').test(contents);
-                readmeAlreadyVersioned ||= alreadyVersioned;
-                if (insertionMarker &&
-                    !alreadyVersioned &&
-                    !readmeUpdated &&
-                    contents.includes(insertionMarker)) {
-                    const readmeSection = `\n\n= ${release.nextVersion} =\n\n${summaries
-                        .map((item) => `* ${item.replaceAll(/\r?\n/g, '\n  ')}`)
-                        .join('\n')}\n\n`;
-                    await rememberFile(journal, file);
-                    await writeFile(file, insertAfterMarker(contents, insertionMarker, readmeSection.trimStart(), file));
-                    readmeUpdated = true;
-                }
-            }
-            catch (error) {
-                if ('ENOENT' !== error.code) {
-                    throw error;
-                }
-            }
-        }
-        if (changelogInsertAfter &&
-            readmeFound &&
-            !readmeMarkerFound &&
-            !readmeAlreadyVersioned) {
-            throw new ValidationError(`Changelog insertion marker "${changelogInsertAfter}" was not found in a plugin readme in ${directory}.`);
-        }
-    }
-}
-function insertAfterMarker(contents, marker, section, file) {
-    const index = contents.indexOf(marker);
-    if (-1 === index) {
-        throw new ValidationError(`Changelog insertion marker "${marker}" was not found in ${file}.`);
-    }
-    const markerEnd = index + marker.length;
-    const after = contents
-        .slice(markerEnd)
-        .replace(/^(?:[ \t]*\r?\n)+/, '');
-    const lineEnding = contents.includes('\r\n') ? '\r\n' : '\n';
-    return `${contents.slice(0, markerEnd)}${lineEnding}${lineEnding}${section.replaceAll('\n', lineEnding)}${after}`;
-}
-async function changedPackagesSince(cwd, packages, since) {
-    const output = await git(cwd, [
-        'diff',
-        '--name-only',
-        `${since}...HEAD`,
-    ]);
-    const changedFiles = output.trim().split(/\r?\n/).filter(Boolean);
-    const filesByPackage = {};
-    const changed = packages.filter((pkg) => {
-        const packageFromRepo = path
-            .relative(cwd, pkg.directory)
-            .split(path.sep)
-            .join('/');
-        const matchingFiles = '.' === packageFromRepo
-            ? changedFiles
-            : changedFiles.filter((file) => file === packageFromRepo ||
-                file.startsWith(`${packageFromRepo}/`));
-        if (matchingFiles.length) {
-            filesByPackage[pkg.name] = matchingFiles;
-        }
-        return matchingFiles.length > 0;
-    });
-    return { packages: changed, filesByPackage };
-}
-function formatTag(format, pkg, version) {
-    const type = pkg.group.tagType ?? defaultTagType(pkg.path, pkg.type);
-    return format
-        .replaceAll('{name}', pkg.name)
-        .replaceAll('{slug}', '.' === pkg.path
-        ? path.basename(pkg.directory)
-        : path.basename(pkg.path))
-        .replaceAll('{path}', pkg.path)
-        .replaceAll('{type}', type)
-        .replaceAll('{version}', version);
-}
-function defaultTagType(packagePath, type) {
-    if ('.' === packagePath && type) {
-        return type;
-    }
-    const first = packagePath.split('/')[0] ?? 'package';
-    const irregular = {
-        actions: 'action',
-        plugins: 'plugin',
-        themes: 'theme',
-        php: 'php',
-        js: 'js',
-    };
-    return irregular[first] ?? first.replace(/s$/, '');
-}
-function formatTemplatePrefix(pattern, packagePath, tagType) {
-    return pattern
-        .replaceAll('{path}', packagePath)
-        .replaceAll('{type}', tagType ?? defaultTagType(packagePath))
-        .replaceAll('{name}', packagePath.split('/').at(-1) ?? packagePath)
-        .replaceAll('{slug}', packagePath.split('/').at(-1) ?? packagePath)
-        .replaceAll('{version}', '');
-}
-async function verifyVersionTargets(cwd, pkg, expected) {
-    for (const target of pkg.versionConfig.to) {
-        let actual;
-        if ('composer-json' === target.kind &&
-            target.ifPresent &&
-            !Object.hasOwn(await readJson(path.join(pkg.directory, target.file)), target.field)) {
-            actual = undefined;
-        }
-        else if ('wordpress-stable-tag' === target.kind &&
-            target.ifPresent &&
-            !(await versionFileExists(pkg.directory, target.kind, target.file))) {
-            actual = undefined;
-        }
-        else {
-            actual = await readVersion(cwd, pkg.directory, target, pkg.path, pkg.group.tagType);
-        }
-        if (undefined !== actual && actual !== expected) {
-            throw new ValidationError(`Version mismatch for ${pkg.name}: expected ${expected}, found ${actual}.`);
-        }
-    }
-}
-async function gitTagExists(cwd, tag) {
-    const result = await git(cwd, ['tag', '--list', tag]);
-    return result.trim() === tag;
-}
-async function git(cwd, args) {
-    const directory = path.resolve(cwd);
-    try {
-        const { stdout } = await execFileAsync('git', ['-c', `safe.directory=${directory}`, ...args], { cwd: directory });
-        return stdout;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ValidationError(`Git command failed (${args.join(' ')}): ${message}`);
-    }
-}
-async function readReleaseNotes(directory, version) {
-    let contents = '';
-    try {
-        contents = await readFile(path.join(directory, 'CHANGELOG.md'), 'utf8');
-    }
-    catch (error) {
-        if ('ENOENT' !== error.code) {
-            throw error;
-        }
-    }
-    const lines = contents.split(/\r?\n/);
-    const headingIndex = lines.findIndex((line) => new RegExp(`^##\\s+${escapeRegExp(version)}(?:\\s|$)`).test(line));
-    if (-1 === headingIndex) {
-        return '';
-    }
-    const followingHeading = lines.findIndex((line, index) => index > headingIndex && /^##\s/.test(line));
-    const end = -1 === followingHeading ? lines.length : followingHeading;
-    return lines
-        .slice(headingIndex + 1, end)
-        .join('\n')
-        .trim();
-}
-async function getLatestChangelogVersion(directory, fallback) {
-    try {
-        const contents = await readFile(path.join(directory, 'CHANGELOG.md'), 'utf8');
-        const match = /^##\s+(\d+\.\d+\.\d+)(?:\s|$)/m.exec(contents);
-        return match?.[1] ?? fallback;
-    }
-    catch (error) {
-        if ('ENOENT' === error.code) {
-            return fallback;
-        }
-        throw error;
-    }
-}
-function escapeRegExp(value) {
-    return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-async function rememberFile(journal, file) {
-    if (journal.has(file)) {
-        return;
-    }
-    try {
-        journal.set(file, await readFile(file, 'utf8'));
-    }
-    catch (error) {
-        if ('ENOENT' !== error.code) {
-            throw error;
-        }
-        journal.set(file, undefined);
-    }
-}
-async function restoreFileJournal(journal) {
-    const errors = [];
-    for (const [file, contents] of [...journal.entries()].reverse()) {
-        try {
-            if (undefined === contents) {
-                await rm(file, { force: true });
-            }
-            else {
-                await writeFile(file, contents);
-            }
-        }
-        catch (error) {
-            errors.push(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    return errors;
-}
-async function readJson(file) {
-    try {
-        return JSON.parse(await readFile(file, 'utf8'));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ValidationError(`Could not read JSON manifest ${file}: ${message}`);
-    }
-}
-function packageType(group) {
-    const kind = group.version.from.kind;
-    if ('wordpress-plugin-header' === kind) {
-        return 'plugin';
-    }
-    if ('wordpress-theme-header' === kind) {
-        return 'theme';
-    }
-    if ('package-json' === kind) {
-        return 'npm';
-    }
-    return 'other';
-}
-const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?$/;
-function isVersion(version) {
-    return VERSION_PATTERN.test(version);
-}
-function isPrerelease(version) {
-    return Boolean(VERSION_PATTERN.exec(version)?.[4]);
-}
-/**
- * Compare two versions with SemVer precedence, where a pre-release like
- * 1.0.0-rc.1 comes before 1.0.0.
- *
- * @param left  Version.
- * @param right Version to compare with.
- * @return Negative when left is lower, positive when higher, otherwise 0.
- */
-function compareVersions(left, right) {
-    const [leftCore = '', leftPre] = splitPrerelease(left);
-    const [rightCore = '', rightPre] = splitPrerelease(right);
-    const a = leftCore.split('.').map(Number);
-    const b = rightCore.split('.').map(Number);
-    const core = (a[0] ?? 0) - (b[0] ?? 0) ||
-        (a[1] ?? 0) - (b[1] ?? 0) ||
-        (a[2] ?? 0) - (b[2] ?? 0);
-    if (core || leftPre === rightPre) {
-        return core;
-    }
-    if (undefined === leftPre || undefined === rightPre) {
-        return undefined === leftPre ? 1 : -1;
-    }
-    return comparePrerelease(leftPre.split('.'), rightPre.split('.'));
-}
-function splitPrerelease(version) {
-    const index = version.indexOf('-');
-    return -1 === index
-        ? [version]
-        : [version.slice(0, index), version.slice(index + 1)];
-}
-function comparePrerelease(left, right) {
-    const [a, ...leftRest] = left;
-    const [b, ...rightRest] = right;
-    if (undefined === a || undefined === b) {
-        return (undefined === a ? 0 : 1) - (undefined === b ? 0 : 1);
-    }
-    const order = compareIdentifier(a, b);
-    return order || comparePrerelease(leftRest, rightRest);
-}
-function compareIdentifier(a, b) {
-    const aNumeric = /^\d+$/.test(a);
-    const bNumeric = /^\d+$/.test(b);
-    if (aNumeric && bNumeric) {
-        return Number(a) - Number(b);
-    }
-    if (aNumeric || bNumeric) {
-        return aNumeric ? -1 : 1;
-    }
-    return Number(a > b) - Number(a < b);
+    return new ChangesetRelease(input).getStatus(input);
 }