@wtf/release-docs 9.1.0 → 10.0.0

package/guides/publishing-maven.md

@@ -110,20 +110,26 @@ nor a JDK, because the trains read the poms with git.
 
 ## What a release does
 
+The plugin works out the plan of the train: the modules it deploys, and the version of each module
+of the repo. Then each step of semantic-release runs a step of the Maven ecosystem, `verify`,
+`prepare` or `publish`, over that plan, and what it says and throws names the train (see [Without semantic-release](#without-semantic-release)).
+
 1. **`verifyConditions`** checks the options and reads the poms. It selects the modules that the
    release deploys and puts them in dependency order. It reads each other train's last release from
-   its tags, and finds each module's repository. A repo that cannot be deployed fails here, before
-   the tag (see [When modules depend on other trains](#when-modules-depend-on-other-trains)).
-2. **`prepare`** writes the versions into the poms: the release's version into the train's poms,
-   and each other train's last release into that train's poms. It also writes them into the
-   parents, dependencies and plugins that name those modules. Then it reads the poms again, and a
-   module that is not at its train's version fails the run (see
-   [What the stamp writes](#what-the-stamp-writes)).
-3. **`publish`** asks each module's repository whether it has the module's pom, and skips each one
+   its tags (see [When modules depend on other trains](#when-modules-depend-on-other-trains)).
+2. **`verifyRelease`** checks the release's version by Maven's rules once semantic-release knows
+   it: a version that ends in `SNAPSHOT`, or holds a space or a character Maven bans, fails with
+   `EMAVENVERSION`. It finds each module's repository. A repo that cannot be deployed fails here,
+   before the tag.
+3. **`prepare`** checks the version again, and writes the versions into the poms: the release's
+   version into the train's poms, and each other train's last release into that train's poms. It also writes them into the parents, dependencies and plugins
+   that name those modules. Then it reads the poms again, and a module that is not at its train's
+   version fails the run (see [What the stamp writes](#what-the-stamp-writes)).
+4. **`publish`** asks each module's repository whether it has the module's pom, and skips each one
    it has. It deploys the rest in dependency order.
 
-A dry run of semantic-release runs only `verifyConditions`. It writes no version and deploys
-nothing.
+A dry run of semantic-release runs only `verifyConditions` and `verifyRelease`. It writes no
+version and deploys nothing.
 
 ### How a module is deployed
 
@@ -136,6 +142,36 @@ from the root of the repo, after the modules it depends on.
   as a test kit with `maven.deploy.skip`. The plugin installs such a module into the local
   repository first.
 
+### Without semantic-release
+
+The library releases the modules of any plan, with no train and no release tool. Its default export
+is a `ReleasingEcosystem` of `@wtf/release/contract`, so `runStep` of `@wtf/release/driver` runs its
+steps. A plan names the modules to deploy, in order, and the version each module of the repo takes:
+
+```ts
+import type { Release } from '@wtf/release/contract'
+import { runStep } from '@wtf/release/driver'
+import maven from '@wtf/release-maven'
+import { publishOrder, readModules, selectArtifacts } from '@wtf/release-maven/artifacts'
+
+/** Every module of the repo that deploys, at the version of the release. */
+export async function releaseAll(release: Release) {
+  const modules = await readModules(release)
+  const names = new Set(modules.map(({ name }) => name))
+  const own = publishOrder(selectArtifacts(modules, { train: names }))
+  const versions = new Map(modules.map(({ name }) => [name, release.version]))
+  const plans = new Map([['maven', { own, versions }]])
+  const ecosystems = [[maven, { args: ['-s', 'ci_settings.xml'] }]] as const
+  await runStep(release, plans, ecosystems, 'verify')
+  await runStep(release, plans, ecosystems, 'prepare')
+  return (await runStep(release, plans, ecosystems, 'publish')).released
+}
+```
+
+The options are the plugin's `repository`, `lookup`, `lookupAuth`, `command` and `args`, and
+`installs`, the modules to install before the ones that need them. A dry run of the release writes
+and deploys nothing.
+
 ## When modules depend on other trains
 
 A repo can be released in several trains. Each train has its own modules, version and tags, and its
@@ -174,6 +210,8 @@ The trains run the same checks for every ecosystem. They run in `verifyCondition
 - A module of the release that depends on a module of a train with no release fails with
   `EDEPENDENCYNORELEASE`.
 - A module that the paths of two trains hold fails with `ETRAINOVERLAP`.
+- A module of the release whose range no release of the other train satisfies fails with
+  `EDEPENDENCYUNSATISFIED` (see [Versions and ranges](#versions-and-ranges)).
 
 In the first two cases there is no version that a repository could serve, so the release never
 deploys the placeholder. A dependency in the `test` scope is not a fault, because no consumer

package/guides/publishing-oci.md

@@ -61,14 +61,18 @@ echo "$CI_REGISTRY_PASSWORD" | crane auth login --username "$CI_REGISTRY_USER" -
 
 ## What a release does
 
-`publish`, in the run of the tag:
+In the run of the tag, `verifyRelease` and `publish` run the steps of the OCI ecosystem of
+`@wtf/release-oci` over the images of the train:
 
-1. finds the snapshot of each image of the train by its digest, `crane digest`, and the platforms of
+1. `verifyRelease` checks the version and the tags that move, each a tag an image can have, once
+   semantic-release knows the version;
+2. finds the snapshot of each image of the train by its digest, `crane digest`, and the platforms of
    its index, `crane manifest`. A snapshot the registry has not, or of fewer platforms than
    `platforms` names, fails the release (`EOCISMOKE`) before anything is copied;
-2. checks the tag of the version: a registry that has it at the same digest skips it, and at another
+3. checks the tag of the version: a registry that has it at the same digest skips it, and at another
    digest refuses the release (`EOCIRETAG`). A released version never moves;
-3. copies the snapshot to the version, then to the minor and the major, which move:
+4. copies the snapshot to the version, and then points the minor and the major, which move, at the
+   digest of the version:
 
 | Version        | Tags                |
 | -------------- | ------------------- |
@@ -76,13 +80,38 @@ echo "$CI_REGISTRY_PASSWORD" | crane auth login --username "$CI_REGISTRY_USER" -
 | `0.3.1`        | `0.3.1`, `0.3`      |
 | `8.0.0-next.1` | `8.0.0-next.1`      |
 
-4. links each image from the GitLab release of the tag to its page in the container registry of the
+5. links each image from the GitLab release of the tag to its page in the container registry of the
    project, which the Container Registry API names (`EOCILINK`). An image is linked where it lives,
    never uploaded.
 
 A release that stopped part way is finished by a retry of its job: the version the registry has at
 the same digest is skipped, and the moving tags are copied again.
 
+## Release images without semantic-release
+
+The OCI ecosystem is a `ReleasingEcosystem` of `@wtf/release/contract`, so any driver releases
+images by it, as a CLI that releases an image of Debian 12.12 as `12.12-wtf.1`, `12.12` and
+`latest`. It takes the version and the tags that move as they are given, and derives none:
+
+```ts
+import type { Plan, Release } from '@wtf/release/contract'
+import { runStep } from '@wtf/release/driver'
+import oci from '@wtf/release-oci'
+
+export async function releaseImages(release: Release, plan: Plan, snapshot: string) {
+  const plans = new Map([['oci', plan]])
+  const options = {
+    moving: ['12.12', 'latest'],
+    source: { repository: '{image}/snapshot', tag: snapshot }
+  }
+  for (const step of ['verify', 'publish', 'move'] as const)
+    // oxlint-disable-next-line no-await-in-loop -- one step after another
+    await runStep(release, plans, [[oci, options]], step)
+}
+```
+
+See [the library's README](../../release-oci/README.md) for each step and its options.
+
 ## Label an image of its version
 
 A release stamps nothing into an image: what was tested ships. A pipeline that labels an image of
@@ -97,7 +126,9 @@ own.
 | `EOCIECOSYSTEM` | Add `'@wtf/semantic-release-oci/ecosystem'` to `ecosystems`                    |
 | `EOCIIMAGE`     | Run the release in a pipeline of GitLab, or give the plugin `image`            |
 | `EOCISOURCE`    | Run the release in the pipeline of its tag, or give the plugin `sourceTag`     |
+| `EOCIVERSION`   | Release a version that is a tag of an image, as `1.4.2`                        |
 | `EOCISMOKE`     | Build and push the snapshot before the release, and log crane in               |
 | `EOCIRETAG`     | Release a new version: the registry has this one at another digest             |
 | `EOCITAG`       | Give crane a token that may write the repository, and retry the job            |
+| `EOCIMOVE`      | Publish the version first: the tags that move point at it                      |
 | `EOCILINK`      | Give the run a token that may read the registry of the project, `GITLAB_TOKEN` |

package/guides/publishing.md

@@ -45,21 +45,21 @@ The plugin does not create the release on GitLab or GitHub. List `@semantic-rele
 `@semantic-release/github` after it. Wrapped in the trains plugin, `@semantic-release/gitlab` links each
 package that the release published: see [The links of the release](#the-links-of-the-release).
 
-| Option       | Default                                  | What it does                                                                                                                                                                                                         |
-| ------------ | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `publisher`  | `npm`                                    | The tool that publishes: `npm`, `pnpm`, the path of a module, or a package name. See [Publishers](#publishers).                                                                                                      |
-| `access`     | each package's `publishConfig.access`    | `public` or `restricted`.                                                                                                                                                                                            |
-| `provenance` | `auto`                                   | Whether to publish with provenance: `auto` (when the CI provides an ID token), `true` or `false`.                                                                                                                    |
-| `registry`   | each package's `publishConfig.registry`  | The registry to publish to.                                                                                                                                                                                          |
-| `first`      | none                                     | The folder of the package to publish first.                                                                                                                                                                          |
-| `last`       | none                                     | The folder of the package to publish last.                                                                                                                                                                           |
-| `conditions` | `['source']`                             | The export conditions that point at source files. No tarball ships them.                                                                                                                                             |
-| `check`      | `true`                                   | Check the packages before the first publish. See [What the check catches](#what-the-check-catches).                                                                                                                  |
-| `aside`      | none                                     | Package names to publish under their major's line when their dist-tag points above the release: `release-<major>.x` in place of `latest`, `<dist-tag>-<major>.x` in place of another.                                |
-| `tarballDir` | a folder in the system's temporary files | Where to keep the tarballs after the release, for the links of a package in `pack` or on a registry with no page. Add a folder in the repo to `.gitignore`. A CI job starts with it empty.                           |
-| `pack`       | none                                     | Folders or globs of private packages in the train. The plugin packs them into `tarballDir` beside the others and never publishes them. The GitLab release links each one's tarball. Use it for a demo.               |
-| `distTag`    | the channel's                            | One dist-tag for every package, in place of the channel's, for a one-off release. An empty string means no override.                                                                                                 |
-| `smoke`      | `false`                                  | `true`, or `{ forbid }` with globs that no tarball may hold. Installs each packed package as a consumer would, in `prepare`, before the tag. See [Smoke-test the packages](#smoke-test-the-packages-before-the-tag). |
+| Option       | Default                                 | What it does                                                                                                                                                                                                         |
+| ------------ | --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `publisher`  | `npm`                                   | The tool that publishes: `npm`, `pnpm`, the path of a module, or a package name. See [Publishers](#publishers).                                                                                                      |
+| `access`     | each package's `publishConfig.access`   | `public` or `restricted`.                                                                                                                                                                                            |
+| `provenance` | `auto`                                  | Whether to publish with provenance: `auto` (when the CI provides an ID token), `true` or `false`.                                                                                                                    |
+| `registry`   | each package's `publishConfig.registry` | The registry to publish to.                                                                                                                                                                                          |
+| `first`      | none                                    | The folder of the package to publish first.                                                                                                                                                                          |
+| `last`       | none                                    | The folder of the package to publish last.                                                                                                                                                                           |
+| `conditions` | `['source']`                            | The export conditions that point at source files. No tarball ships them.                                                                                                                                             |
+| `check`      | `true`                                  | Check the packages before the first publish. See [What the check catches](#what-the-check-catches).                                                                                                                  |
+| `aside`      | none                                    | Package names to publish under their major's line when their dist-tag points above the release: `release-<major>.x` in place of `latest`, `<dist-tag>-<major>.x` in place of another.                                |
+| `tarballDir` | a temporary folder of the platform      | Where to keep the tarballs after the release, for the links of a package in `pack` or on a registry with no page. Add a folder in the repo to `.gitignore`. A CI job starts with it empty.                           |
+| `pack`       | none                                    | Folders or globs of private packages in the train. The plugin packs them into `tarballDir` beside the others and never publishes them. The GitLab release links each one's tarball. Use it for a demo.               |
+| `distTag`    | the channel's                           | One dist-tag for every package, in place of the channel's, for a one-off release. An empty string means no override.                                                                                                 |
+| `smoke`      | `false`                                 | `true`, or `{ forbid }` with globs that no tarball may hold. Installs each packed package as a consumer would, in `prepare`, before the tag. See [Smoke-test the packages](#smoke-test-the-packages-before-the-tag). |
 
 ### Provenance
 
@@ -87,39 +87,45 @@ JSON leaves out, and the channel's dist-tag applies.
 
 ## What a release does
 
-A release runs three steps. Each step is a function of `@wtf/release-npm/release`.
+The plugin runs on the steps of the npm ecosystem of `@wtf/release-npm`, each over the plan of the
+train. The plan is the train's packages that publish, in order, and the version of each package of
+the repo that a range resolves to. `planOf` from `@wtf/release-trains/plan` works it out:
 
-1. **Resolve the manifests** (`resolveManifests`). The plugin finds the train's packages that
-   publish: every package under the train's `paths` that is not private. It finds them the way the
-   package manager does, by the globs in `pnpm-workspace.yaml` or in the `workspaces` field of
-   `package.json`. It orders them so that each package comes after the packages it runs with
-   (`dependencies`, `peerDependencies` and `optionalDependencies`). `first` and `last` pin a package
-   to either end. Then it builds each manifest as it will publish:
+- It finds the train's packages that publish: every package under the train's `paths` that is not
+  private. It finds them the way the package manager does, by the globs in `pnpm-workspace.yaml`
+  or in the `workspaces` field of `package.json`.
+- It orders them so that each package comes after the packages it runs with (`dependencies`,
+  `peerDependencies` and `optionalDependencies`). `first` and `last` pin a package to either end.
+- Each package in the same train gets the release's version. Each package in another train gets
+  that train's last release, which `planOf` reads from the tags. A train's cascade reads the same
+  tags.
+
+Then the steps of the library, each a function of `@wtf/release-npm/release`, release the plan:
+
+1. **Resolve the manifests** (`resolvePlan`). The library builds each manifest as it will publish:
    - The version is the release's version.
-   - Each `workspace:` range on a package in the same train resolves to that version, the way pnpm
-     resolves `workspace:*`, `workspace:^` and `workspace:~`.
-   - Each `workspace:` range on a package in another train resolves to that train's last release,
-     which the plugin reads from the tags. `releasedVersions` from `@wtf/release-trains/packages`
-     and `resolveSpecifier` from `@wtf/release-npm/manifests` do this, and a train's cascade reads
-     the same functions.
-   - The plugin drops a devDependency whose `workspace:` range points at a package that no train
-     releases, such as a private package of shared configs, or at a train with no release yet. No
-     consumer installs a devDependency.
-   - The plugin strips each export that points at source: the `source` condition, or a `.ts`
+   - Each `workspace:` range resolves to the version of the plan of the package it names, the way
+     pnpm resolves `workspace:*`, `workspace:^` and `workspace:~` (`resolveSpecifier` from
+     `@wtf/release-npm/manifests`).
+   - The library drops a devDependency whose `workspace:` range points at a package of no version
+     in the plan, such as a private package of shared configs, or of a train with no release yet.
+     No consumer installs a devDependency.
+   - The library strips each export that points at source: the `source` condition, or a `.ts`
      target.
 
    Then it checks each manifest. This step writes nothing.
 
-2. **Pack the tarballs** (`packTrain`). The plugin copies each package, without its `node_modules`,
-   into a folder in the system's temporary files. It writes the resolved manifest into the copy and
-   packs the copy there. It packs every package before the first publish, so a fault stops the run
-   before anything reaches the registry.
+2. **Pack the tarballs** (`packRelease`). The library copies each package, without its
+   `node_modules`, into a temporary folder of the platform. It writes the resolved manifest into the
+   copy and packs the copy there. It packs every package before the first publish, so a fault stops
+   the run before anything reaches the registry.
 
-3. **Publish** (`publishTrain`). The plugin publishes each package under the dist-tag of the
-   release's channel. That is `latest`, or `beta` for `2.1.0-beta.3`, or `prerelease` for
-   `2.1.0-0`. A channel that npm would read as a range, such as `1.x` on a maintenance branch,
-   becomes `release-1.x`. The plugin adds provenance where the CI provides an ID token, and skips
-   each version that the registry already has.
+3. **Publish** (`publishPacked`). The library publishes each package under the first dist-tag the
+   plugin gives it, `moving`, which the plugin derives from the release's channel. That is
+   `latest`, or `beta` for `2.1.0-beta.3`, or `prerelease` for `2.1.0-0`. A channel that npm would
+   read as a range, such as `1.x` on a maintenance branch, becomes `release-1.x`. The library adds
+   provenance where the CI provides an ID token, and skips each version that the registry already
+   has.
 
 ### When a dist-tag would move back
 
@@ -137,25 +143,29 @@ release, the run fails too. A release whose channel is a line already, such as `
 
 ### Which semantic-release step does what
 
-The plugin implements the same steps as `@semantic-release/npm`:
+The plugin implements the same steps as `@semantic-release/npm`. Each maps onto a step of the
+library:
 
-- `verifyConditions` checks the publisher and the packages as they are in the repo.
-- `prepare` runs steps 1 and 2 and asks the registry, all before the tag. These faults fail the run
-  here:
+- `verifyConditions` checks its options and the publisher, and the packages as they are in the repo
+  (`checkPlan`, the library's `verify` but of the version, which semantic-release has not yet).
+- `verifyRelease` runs the library's `verify`, which checks the version once semantic-release knows
+  it, and the packages of the train.
+- `prepare` runs the library's `prepare`, steps 1 and 2, which asks the registry too, and, with
+  `smoke`, its `smoke`, all before the tag. These faults fail the run here:
   - a range that no release satisfies (`EDEPENDENCYUNSATISFIED`);
   - a dependency on a train with no release (`EDEPENDENCYNORELEASE`);
   - a dependency on a package of no train (`EDEPENDENCYNOTRAIN`);
   - a package that cannot be packed;
   - a release that would move a dist-tag back (`EPUBLISHBEHIND`).
-- `publish` runs step 3 with what `prepare` packed, after the tag is pushed. It returns the release
-  to semantic-release as the stock plugin does: the publisher's name and its packages, the page of
-  the first package, and the channel. Then it removes the copies and the tarballs. With
-  `tarballDir`, it keeps the tarballs. If `publish` finds nothing packed for its train and version
-  in the same process, it resolves and packs again.
-- `addChannel` moves a published release to the dist-tag of its new channel, by `tagTrain`.
-  semantic-release asks for this when you merge a branch of one channel into the branch of another.
-  The plugin runs `npm dist-tag add` for each package of the train that the registry has at the
-  version, with either built-in publisher.
+- `publish` runs the library's `publish`, step 3, with what `prepare` packed, after the tag is
+  pushed. It returns the release to semantic-release as the stock plugin does: the publisher's name
+  and its packages, the page of the first package, and the channel. Then it removes the copies and
+  the tarballs. With `tarballDir`, it keeps the tarballs. If `publish` finds nothing packed for its
+  train and version in the same process, it resolves and packs again.
+- `addChannel` moves a published release to the dist-tag of its new channel, by the library's
+  `move` (`moveRelease`). semantic-release asks for this when you merge a branch of one channel into
+  the branch of another. The plugin runs `npm dist-tag add` for each package of the train that the
+  registry has at the version, with either built-in publisher.
 
 npm moves a dist-tag only with the token in its config. Its trusted publishing covers
 `npm publish` and no other command, so a release from a channel branch needs `NPM_TOKEN` too. A
@@ -182,8 +192,8 @@ tries the private packages of `pack` too. It does this with `smokePacked` from
 - **In the tarball:** an entry of `files` that the tarball does not hold, as when a package was
   packed without a build; an export with a source condition; a file that matches `forbid`, such as
   `**/*.tsbuildinfo`.
-- **In the install:** npm installs the package in a project of its own in the system's temporary
-  files. Every other packed package installs from its tarball through npm's `overrides`, so npm does
+- **In the install:** npm installs the package in a project of its own in a temporary folder of
+  the platform. Every other packed package installs from its tarball through npm's `overrides`, so npm does
   not ask the registry for any of them.
 - **In the imports:** the plugin imports each entry of `exports`, except `./package.json` and
   patterns. It reports a `SyntaxError`, a module not found that is neither an optional peer in the
@@ -302,31 +312,38 @@ commits on top. See [Run releases in CI](ci-recipes.md#gitlab-ci).
 
 ## Use the steps as a library
 
-The three steps are functions of `@wtf/release-npm/release` and need no release tool. Each step runs
-on the `system` that its caller passes, as a CLI passes its own system adapted to the interface:
+The steps are those of the npm ecosystem, the default export of `@wtf/release-npm`, and need no
+release tool and no train. Each step takes the release, the plan and the options of the library.
+The release carries the folder of the repo and the platform that its caller passes, as a CLI passes
+its own (see [The platform](platform.md)). The plan is the packages that publish, in order, and the
+version of each package of the repo. The options name `moving`, the dist-tags a publish puts the
+version under, which npm always publishes under one of. `runStep` from `@wtf/release/driver` runs a
+step of each ecosystem of a release:
 
 ```ts
-import type { System } from '@wtf/release-system/system'
-import { packTrain, publishTrain, resolveManifests } from '@wtf/release-npm/release'
-
-export async function release(system: System, version: string) {
-  const resolved = await resolveManifests({
-    trains: { trains: { paths: ['packages/release-trains', 'packages/release-trains-*'] } },
-    train: 'trains',
-    version,
-    system
-  })
-  const packed = await packTrain(resolved, { system })
-  try {
-    return await publishTrain(packed, { system, dryRun: true })
-  } finally {
-    await packed.cleanup()
-  }
+import type { Release } from '@wtf/release/contract'
+import { runStep } from '@wtf/release/driver'
+import npm from '@wtf/release-npm'
+
+export async function release(at: Release) {
+  const own = (await npm.packages(at)).filter(
+    ({ dir, published }) => published && dir.startsWith('packages/')
+  )
+  const versions = new Map(own.map(({ name }) => [name, at.version]))
+  const plans = new Map([['npm', { own, versions }]])
+  const ecosystems = [[npm, { moving: ['next'] }]] as const
+  await runStep(at, plans, ecosystems, 'verify')
+  await runStep(at, plans, ecosystems, 'prepare')
+  const { released } = await runStep(at, plans, ecosystems, 'publish')
+  return released
 }
 ```
 
-`releaseTrain` runs all three in one call, the way a job in the tag's pipeline publishes its
-release. See [Publish from the tag pipeline](ci-recipes.md#publish-from-the-tag-pipeline).
+The plan here is every package of the repo under `packages/` that publishes, in the order the
+ecosystem reads them. A driver that publishes in order of the dependencies works the order out by `publishOrder`
+from `@wtf/release/order`, as `planOf` does. See [Publish from the tag
+pipeline](ci-recipes.md#publish-from-the-tag-pipeline) for the run of a release in the tag's
+pipeline.
 
 ## Publishers
 
@@ -356,7 +373,8 @@ A publisher can also have these optional members:
   as `options.tarball`.
 - `page`: it returns a package's page, which the plugin passes to semantic-release as the release's
   URL.
-- `tag`: it points a dist-tag at a version the registry has, for `addChannel` and `tagTrain`.
+- `tag`: it points a dist-tag at a version the registry has, for `addChannel` and the library's
+  `move`.
   Without it, a release cannot move to another channel.
 
 The plugin does not check whether a `lookup` without `tagged` would move a dist-tag back.
@@ -385,13 +403,14 @@ registry:
 
 ```js train=trains
 // release/yarn-publisher.mjs
+import { run } from '@wtf/release/process'
 import { npmPublisher } from '@wtf/release-npm/publishers'
 
 /** @type {import('@wtf/release-npm').Publisher} */
 export default {
   name: 'yarn',
   lookup: npmPublisher.lookup,
-  async publish(pkg, options, { system, env, dryRun, memo }) {
+  async publish(pkg, options, { platform, dryRun, memo }) {
     // The npm lookup keeps what it asked in the step's store: a publisher forgets what it changes.
     memo?.clear()
     if (dryRun) return
@@ -402,7 +421,7 @@ export default {
       options.tag,
       ...(options.access ? ['--access', options.access] : [])
     ]
-    const { code, stderr } = await system.exec('yarn', args, { cwd: pkg.dir, env })
+    const { code, stderr } = await run(platform, 'yarn', args, { cwd: pkg.dir })
     if (code !== 0) throw new Error(stderr)
   }
 }
@@ -446,18 +465,20 @@ echo "//${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/:_authTo
 
 ```js train=trains
 // release/jsr-publisher.mjs
+import { run } from '@wtf/release/process'
+
 /** @type {import('@wtf/release-npm').Publisher} */
 export default {
   name: 'jsr',
-  async lookup(pkg, version, _tag, { system, env }) {
+  async lookup(pkg, version, _tag, { platform }) {
     const meta = `https://jsr.io/${pkg.name}/${version}_meta.json`
-    const { code } = await system.exec('curl', ['--fail', '--silent', '--head', meta], { env })
+    const response = await platform.fetch(meta, { method: 'HEAD' })
     // JSR has no dist-tags: no `tagged`.
-    return { published: code === 0 }
+    return { published: response.ok }
   },
-  async publish(pkg, _options, { system, env, dryRun }) {
+  async publish(pkg, _options, { platform, dryRun }) {
     const args = ['jsr', 'publish', '--allow-dirty', ...(dryRun ? ['--dry-run'] : [])]
-    const { code, stderr } = await system.exec('npx', args, { cwd: pkg.dir, env })
+    const { code, stderr } = await run(platform, 'npx', args, { cwd: pkg.dir })
     if (code !== 0) throw new Error(stderr)
   }
 }

package/guides/troubleshooting.md

@@ -61,14 +61,14 @@ behind the branch.
 
 ## Error codes
 
-Every error of these packages is a `ReleaseError` from `@wtf/release-system/errors`, in the error
-class of its package: `TrainsError` from `@wtf/release-trains/errors`, or `ReplaceError` from
-`@wtf/release-replace/errors`. semantic-release prints them as it prints its own errors: the code,
-the message, and the details, which say how to fix it. A step that finds more than one fault reports
-all of them.
+Every error of these packages is a `ReleaseError` from `@wtf/release/errors`, in the error class of
+its package: `TrainsError` from `@wtf/release-trains/errors`, or `ReplaceError` from
+`@wtf/release-replace/errors`. Each plugin marks them as they leave its steps, so semantic-release
+prints them as it prints its own errors: the code, the message, and the details, which say how to
+fix it. A step that finds more than one fault reports all of them.
 
 When git fails, the error is `EGIT`, itself a `ReleaseError`. A validator of options from
-`@wtf/release-system` fails with `EOPTIONS`, or with the code its check gives, in the error class of
+`@wtf/release` fails with `EOPTIONS`, or with the code its check gives, in the error class of
 the package that asks.
 
 This page lists the codes of the trains, npm and replace packages. The other packages describe their
@@ -187,7 +187,7 @@ Package: `release-trains`.
 
 ### `EECOSYSTEM`
 
-Package: `release-trains`.
+Package: `release`.
 
 **Cause:** An ecosystem in `ecosystems` cannot be loaded, is not an ecosystem, or has the same name
 as another.
@@ -197,7 +197,7 @@ there. Name each ecosystem once.
 
 ### `EGIT`
 
-Package: `release-system`.
+Package: `release`.
 
 **Cause:** git failed, for example in a shallow clone.
 
@@ -213,7 +213,7 @@ Package: `release-npm`.
 
 ### `EGENERATED`
 
-Package: `release-trains`.
+Package: `release`.
 
 **Cause:** A generated folder to list is not there.
 
@@ -354,19 +354,19 @@ Each package exports its codes with what they mean:
 
 | Export           | Module                                |
 | ---------------- | ------------------------------------- |
-| `SYSTEM_ERRORS`  | `@wtf/release-system/errors`          |
+| `RELEASE_ERRORS` | `@wtf/release/errors`                 |
 | `TRAINS_ERRORS`  | `@wtf/release-trains/errors`          |
 | `PLUGIN_ERRORS`  | `@wtf/semantic-release-trains/errors` |
 | `NPM_ERRORS`     | `@wtf/release-npm/errors`             |
 | `REPLACE_ERRORS` | `@wtf/release-replace/errors`         |
 
 ```ts
+import { RELEASE_ERRORS, ReleaseError } from '@wtf/release/errors'
 import { REPLACE_ERRORS } from '@wtf/release-replace/errors'
-import { ReleaseError, SYSTEM_ERRORS } from '@wtf/release-system/errors'
 import { TRAINS_ERRORS } from '@wtf/release-trains/errors'
 
 const MEANINGS: Readonly<Record<string, string>> = {
-  ...SYSTEM_ERRORS,
+  ...RELEASE_ERRORS,
   ...TRAINS_ERRORS,
   ...REPLACE_ERRORS
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtf/release-docs",
-  "version": "9.1.0",
+  "version": "10.0.0",
   "description": "The guides of semantic-release for monorepos of more than one ecosystem, released in trains, and the API reference of its packages, which TypeDoc writes: the release of docs commits the reference and publishes it with the guides.",
   "keywords": [
     "documentation",
@@ -38,23 +38,29 @@
   "devDependencies": {
     "@standard-schema/spec": "^1.1.0",
     "@types/node": "^24.10.0",
-    "@wtf/release-cargo": "3.2.0",
-    "@wtf/release-go": "1.1.0",
-    "@wtf/release-maven": "1.1.0",
-    "@wtf/release-npm": "1.2.0",
-    "@wtf/release-oci": "1.0.0",
-    "@wtf/release-replace": "4.0.0",
-    "@wtf/release-system": "1.0.1",
-    "@wtf/release-trains": "8.0.2",
-    "@wtf/release-validate": "4.0.0",
-    "@wtf/semantic-release-cargo": "3.2.0",
-    "@wtf/semantic-release-go": "1.1.0",
-    "@wtf/semantic-release-maven": "1.1.0",
-    "@wtf/semantic-release-npm": "1.2.0",
-    "@wtf/semantic-release-oci": "1.0.0",
-    "@wtf/semantic-release-replace": "4.0.0",
-    "@wtf/semantic-release-trains": "8.0.2",
-    "@wtf/semantic-release-validate": "4.0.0",
+    "@wtf/platform": "^1.0.0",
+    "@wtf/platform-fs-memory": "^1.0.0",
+    "@wtf/platform-fs-node": "^1.0.0",
+    "@wtf/platform-memory": "^1.0.0",
+    "@wtf/platform-node": "^1.0.0",
+    "@wtf/release": "1.0.0",
+    "@wtf/release-cargo": "4.0.0",
+    "@wtf/release-go": "2.0.0",
+    "@wtf/release-maven": "2.0.0",
+    "@wtf/release-npm": "2.0.0",
+    "@wtf/release-oci": "3.0.0",
+    "@wtf/release-replace": "5.0.0",
+    "@wtf/release-trains": "9.0.0",
+    "@wtf/release-validate": "5.0.0",
+    "@wtf/semantic-release": "1.0.0",
+    "@wtf/semantic-release-cargo": "4.0.0",
+    "@wtf/semantic-release-go": "2.0.0",
+    "@wtf/semantic-release-maven": "2.0.0",
+    "@wtf/semantic-release-npm": "2.0.0",
+    "@wtf/semantic-release-oci": "3.0.0",
+    "@wtf/semantic-release-replace": "5.0.0",
+    "@wtf/semantic-release-trains": "9.0.0",
+    "@wtf/semantic-release-validate": "4.0.1",
     "ajv": "^8.20.0",
     "semantic-release": "^25.0.9",
     "typedoc": "^0.28.20",

package/api/@wtf/release-go/tags/variables/RELEASE_AUTHOR.md

@@ -1,23 +0,0 @@
-[**Release trains**](../../../../README.md)
-
-***
-
-[Release trains](../../../../README.md) / [@wtf/release-go/tags](../README.md) / RELEASE\_AUTHOR
-
-# Variable: RELEASE\_AUTHOR
-
-> `const` **RELEASE\_AUTHOR**: `object`
-
-Defined in: [packages/release-go/src/tags.ts:32](https://gitlab.com/wetryfun/release/release/-/blob/838e75e66ef604439e05c0180870e65b00370ea2/packages/release-go/src/tags.ts#L32)
-
-The author and the committer of a release commit, where the environment names none.
-
-## Type Declaration
-
-### email
-
-> `readonly` **email**: `"semantic-release-bot@martynus.net"` = `'semantic-release-bot@martynus.net'`
-
-### name
-
-> `readonly` **name**: `"semantic-release-bot"` = `'semantic-release-bot'`