rman 2.0.0-beta.2 → 2.0.0-beta.4

package/README.md

@@ -86,7 +86,6 @@ worked examples of every single command, see **[docs/cli-rman.md](https://github
 | [`test`](#rman-test) | Alias for `run test`. |
 | [`exec <command..>`](#rman-exec-command) | Runs an arbitrary shell command in each package. |
 | [`config`](#rman-config) | Prints the effective `.rmanrc` config for the current directory's package. |
-| [`changed`](#rman-changed) | Shows which packages the next `version` run would bump. |
 | [`diff [package]`](#rman-diff-package) | Shows the git diff since a package's (or the repo's) last release tag. |
 | [`changelog`](#rman-changelog) | Generates a changelog per package from unreleased commits. |
 | [`version [bump]`](#rman-version-bump) | Bumps versions of changed packages (and their dependents). |
@@ -141,7 +140,7 @@ rman list --json                # full detail as JSON
 rman list --parseable           # location::name::version::PRIVATE::STATUS lines, for scripting
 rman list --toposort            # dependencies before dependents, instead of directory order
 rman list --graph               # dependency graph as a JSON adjacency list
-rman list --changed             # only packages changed since the last publish
+rman list --changed             # only packages you have touched but not pushed
 rman list --changed-since HEAD~5
 rman list --scope '@myorg/*' --ignore '*-internal'
 ```
@@ -165,7 +164,7 @@ Runs an npm script in each package, in dependency order by default.
 ```bash
 rman run build
 rman run lint --topo=false          # independent packages, alphabetical order, no dependency waiting
-rman run test --changed             # only in packages changed since the last publish
+rman run test --changed             # only in packages you have touched but not pushed
 rman run build --changed-since v1.2.0
 rman run build --parallel 4         # at most 4 packages at once
 rman run build --parallel false     # serially, one at a time
@@ -216,15 +215,6 @@ rman config --from-root           # the repository root's own config instead
 rman config --json | jq .run
 ```
 
-### `rman changed`
-
-Shows which packages the next `rman version` run would bump, without changing anything.
-
-```bash
-rman changed
-rman changed --json
-```
-
 ### `rman diff [package]`
 
 Shows the git diff since a package's (or the whole repository's) last release tag.

package/{plugins/node/augmentation/rman.augmentation.d.ts → builtins/platforms/node/augmentation/rmanrc.augmentation.d.ts}

@@ -1,5 +1,4 @@
-import type cleanCommand from '../commands/clean.command.js';
-import type { CleanExtraKeys } from '../commands/clean.command.js';
+import type { cleanCommand, CleanExtraKeys } from '../commands/clean.command.js';
 import type { NodeConfigKeys, RmanNodeConfig } from '../node-config.interface.js';
 import type { CiService } from '../services/ci.service.js';
 /**
@@ -16,7 +15,7 @@ import type { CiService } from '../services/ci.service.js';
  * (`augmentSystemInfo()`, `augmentManifest()`, ...); this file is imported by the plugin's entry
  * point purely so a consumer's compiler loads it.
  */
-declare module '../../../interfaces/rman-config.interface.js' {
+declare module '../../../../interfaces/rman-config.interface.js' {
     /**
      * The `.rmanrc` keys that only mean something in a Node repository - merged into the core's own
      * key list, so `pkg.config.clean` is typed wherever it is read (`CleanService` included) without
@@ -49,7 +48,7 @@ declare module '../../../interfaces/rman-config.interface.js' {
  * declared in `publish.command.ts` was reachable only by re-declaring it - which now reads as two
  * interfaces of one name and is refused. Each interface is augmented where it lives.
  */
-declare module '../../../commands/publish.command.js' {
+declare module '../../../../commands/publish.command.js' {
     /**
      * The `npm` publish target's own `publish.*` block, declared the way the core's `docker` target
      * declares `publish.docker` - through the slot `publish` contributes, rather than into a central
@@ -68,7 +67,7 @@ declare module '../../../commands/publish.command.js' {
  * runtime half is `augmentSystemInfo()` in the file beside this one, called when the built-in is
  * registered rather than at import, so a repository that never named it reports no npm.
  */
-declare module '../../../services/system-info.js' {
+declare module '../../../../services/system-info.js' {
     namespace SystemInfo {
         type PackageManager = CiService.PackageManager;
         interface Options {

package/{plugins → builtins/platforms}/node/augmentation/system-info.augmentation.js

@@ -1,4 +1,4 @@
-import { SystemInfo as OrgSystemInfo } from '../../../services/system-info.js';
+import { SystemInfo as OrgSystemInfo } from '../../../../services/system-info.js';
 /**
  * Adds the npm half of `SystemInfo` to rman's own types.
  *

package/{plugins → builtins/platforms}/node/commands/ci.command.d.ts

@@ -1,4 +1,4 @@
-import type { ArgsOf } from '../../../index.js';
+import type { ArgsOf } from '../../../../index.js';
 /** Hoisted out of the metadata literal so the handler can be annotated against them - see
  *  `RmanConfig.ArgsOf` for why an inferred `argv` and the metadata's own typo checking cannot both
  *  work in one signature. */
@@ -67,8 +67,10 @@ type Args = ArgsOf<typeof config, typeof COMMAND>;
  * The repository arrives through `app` when the factory runs (in `cli.ts`, after `Repository.create`
  * has attached one), rather than through a `CommandContext` per invocation.
  */
-declare const ciCommand: (app: import("../../../index.js").RmanApplication) => {
+export declare const ciCommand: (app: import("../../../../index.js").RmanApplication) => {
     command: "ci";
+    /** npm's alone: it installs through a Node package manager, from a Node lockfile. */
+    platforms: string[];
     describe: string;
     /** Read, not owned: `packageManager` is a root-level key this package declares in
      *  `NodeConfigKeys`, and the `npm` publish target reads it too. */
@@ -128,4 +130,4 @@ declare const ciCommand: (app: import("../../../index.js").RmanApplication) => {
     }[];
     handler: (args: Args) => Promise<void>;
 };
-export default ciCommand;
+export {};

package/{plugins → builtins/platforms}/node/commands/ci.command.js

@@ -1,6 +1,6 @@
-import { declareCommand } from '../../../interfaces/rman-config.interface.js';
-import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../../../utils/branch-guard.js';
-import { packageFilterOptions, readPackageFilterOptions } from '../../../utils/package-filter.js';
+import { declareCommand } from '../../../../interfaces/rman-config.interface.js';
+import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../../../../utils/branch-guard.js';
+import { packageFilterOptions, readPackageFilterOptions } from '../../../../utils/package-filter.js';
 import { CiService } from '../services/ci.service.js';
 /** Hoisted out of the metadata literal so the handler can be annotated against them - see
  *  `RmanConfig.ArgsOf` for why an inferred `argv` and the metadata's own typo checking cannot both
@@ -35,10 +35,12 @@ const config = {
  * The repository arrives through `app` when the factory runs (in `cli.ts`, after `Repository.create`
  * has attached one), rather than through a `CommandContext` per invocation.
  */
-const ciCommand = declareCommand(app => {
+export const ciCommand = declareCommand(app => {
     const repository = app.repository;
     return {
         command: COMMAND,
+        /** npm's alone: it installs through a Node package manager, from a Node lockfile. */
+        platforms: ['node'],
         describe: 'Deletes node_modules and lockfiles in every package, then reinstalls from scratch',
         /** Read, not owned: `packageManager` is a root-level key this package declares in
          *  `NodeConfigKeys`, and the `npm` publish target reads it too. */
@@ -56,4 +58,3 @@ const ciCommand = declareCommand(app => {
         },
     };
 });
-export default ciCommand;

package/{plugins → builtins/platforms}/node/commands/clean.command.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigValue } from '../../../core/config.js';
-import type { ArgsOf } from '../../../index.js';
+import type { ArgsOf } from '../../../../index.js';
+import type { ConfigValue } from '../../../../interfaces/rman-config.interface.js';
 /** Hoisted for `ArgsOf` - see `ci.command.ts` and `RmanConfig.ArgsOf`. */
 declare const COMMAND: "clean";
 declare const config: {
@@ -91,8 +91,10 @@ type Args = ArgsOf<typeof config, typeof COMMAND>;
  * Declared the same way `ci` is - see that file for why a plugin uses `declareCommand` rather than
  * `registerCommand`.
  */
-declare const cleanCommand: (app: import("../../../index.js").RmanApplication) => {
+export declare const cleanCommand: (app: import("../../../../index.js").RmanApplication) => {
     command: "clean";
+    /** npm's alone: it deletes TypeScript build output, which no other ecosystem has. */
+    platforms: string[];
     describe: string;
     /**
      * **No `configKeys`, because `clean` is this command's *own* key now** - derived from the
@@ -180,4 +182,4 @@ declare const cleanCommand: (app: import("../../../index.js").RmanApplication) =
     })[];
     handler: (args: Args) => Promise<void>;
 };
-export default cleanCommand;
+export {};

package/{plugins → builtins/platforms}/node/commands/clean.command.js

@@ -1,6 +1,6 @@
-import { declareCommand } from '../../../interfaces/rman-config.interface.js';
-import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../../../utils/branch-guard.js';
-import { fromRootOption, packageFilterOptions, readPackageFilterOptions } from '../../../utils/package-filter.js';
+import { declareCommand } from '../../../../interfaces/rman-config.interface.js';
+import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../../../../utils/branch-guard.js';
+import { fromRootOption, packageFilterOptions, readPackageFilterOptions } from '../../../../utils/package-filter.js';
 import { CleanService } from '../services/clean.service.js';
 /** Hoisted for `ArgsOf` - see `ci.command.ts` and `RmanConfig.ArgsOf`. */
 const COMMAND = 'clean';
@@ -35,10 +35,12 @@ const config = {
  * Declared the same way `ci` is - see that file for why a plugin uses `declareCommand` rather than
  * `registerCommand`.
  */
-const cleanCommand = declareCommand(app => {
+export const cleanCommand = declareCommand(app => {
     const repository = app.repository;
     return {
         command: COMMAND,
+        /** npm's alone: it deletes TypeScript build output, which no other ecosystem has. */
+        platforms: ['node'],
         describe: 'Removes compiled TypeScript output and any extra files/dirs configured via .rmanrc "clean"',
         /**
          * **No `configKeys`, because `clean` is this command's *own* key now** - derived from the
@@ -70,4 +72,3 @@ const cleanCommand = declareCommand(app => {
         },
     };
 });
-export default cleanCommand;

package/builtins/platforms/node/index.d.ts

@@ -0,0 +1,8 @@
+export * from './augmentation/rmanrc.augmentation.js';
+export * from './augmentation/system-info.augmentation.js';
+export * from './commands/ci.command.js';
+export * from './commands/clean.command.js';
+export * from './node.platform.js';
+export * from './node-config.interface.js';
+export * from './node-manifest.provider.js';
+export * from './utils/workspace-range.js';

package/builtins/platforms/node/index.js

@@ -0,0 +1,8 @@
+export * from './augmentation/rmanrc.augmentation.js';
+export * from './augmentation/system-info.augmentation.js';
+export * from './commands/ci.command.js';
+export * from './commands/clean.command.js';
+export * from './node.platform.js';
+export * from './node-config.interface.js';
+export * from './node-manifest.provider.js';
+export * from './utils/workspace-range.js';

package/{plugins → builtins/platforms}/node/node-config.interface.d.ts

@@ -1,5 +1,4 @@
-import type { ConfigValue } from '../../core/config.js';
-import type { RmanConfig, ScopedVars } from '../../interfaces/rman-config.interface.js';
+import type { ConfigValue, RmanConfig, ScopedVars } from '../../../interfaces/rman-config.interface.js';
 import type { CiService } from './services/ci.service.js';
 /**
  * The `.rmanrc` keys that only mean something because the repository is a Node one.

package/{plugins → builtins/platforms}/node/node-manifest.provider.d.ts

@@ -1,6 +1,6 @@
-import type { ManifestProvider } from '../../core/manifest.js';
-import { Manifest } from '../../core/manifest.js';
-import type { Package } from '../../core/package.js';
+import type { Package } from '../../../core/classes/package.js';
+import type { ManifestProvider } from '../../../core/interfaces/manifest.js';
+import { Manifest } from '../../../core/interfaces/manifest.js';
 export declare class NodeManifestProvider implements ManifestProvider {
     name: string;
     fileName: string;

package/{plugins → builtins/platforms}/node/node-manifest.provider.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { Manifest } from '../../core/manifest.js';
-import { stampVersionConstant } from '../../utils/version-stamp.js';
-import { npmViewVersion } from './utils/npm-view.js';
+import { Manifest } from '../../../core/interfaces/manifest.js';
+import { stampVersionConstant } from '../../../utils/version-stamp.js';
+import { npmViewVersion } from '../../publish-targets/npm/npm-view.js';
 import { parseWorkspaceRange } from './utils/workspace-range.js';
 export class NodeManifestProvider {
     name = 'node';

package/{plugins → builtins/platforms}/node/node.platform.d.ts

@@ -1,6 +1,6 @@
-import type { Package } from '../../core/package.js';
-import type { Platform } from '../../core/plugin.js';
-import type { RunService } from '../../services/run.service.js';
+import type { Package } from '../../../core/classes/package.js';
+import type { Platform } from '../../../core/interfaces/plugin.js';
+import type { RunService } from '../../../services/run.service.js';
 import { NodeManifestProvider } from './node-manifest.provider.js';
 import { NodeVersionPlanService } from './services/version-plan.service.js';
 export declare class NodePlatform implements Platform {

package/{plugins → builtins/platforms}/node/services/ci.service.d.ts

@@ -1,6 +1,6 @@
-import type { Repository } from '../../../core/repository.js';
-import type { LogLevel } from '../../../utils/logger.js';
-import type { PackageFilterOptions } from '../../../utils/package-filter.js';
+import type { Repository } from '../../../../core/classes/repository.js';
+import type { LogLevel } from '../../../../utils/logger.js';
+import type { PackageFilterOptions } from '../../../../utils/package-filter.js';
 export declare namespace CiService {
     /**
      * The package managers this plugin knows how to drive, and the `choices` both `ci --package-manager`

package/{plugins → builtins/platforms}/node/services/ci.service.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import colors from 'ansi-colors';
-import { exec } from '../../../utils/exec.js';
-import { Logger, resolveRootLogLevel } from '../../../utils/logger.js';
-import { filterPackages } from '../../../utils/package-filter.js';
-import { formatDuration, ProgressPanel } from '../../../utils/progress-panel.js';
+import { exec } from '../../../../utils/exec.js';
+import { Logger, resolveRootLogLevel } from '../../../../utils/logger.js';
+import { filterPackages } from '../../../../utils/package-filter.js';
+import { formatDuration, ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CiService;
 (function (CiService) {
     /**

package/{plugins → builtins/platforms}/node/services/clean.service.d.ts

@@ -1,6 +1,6 @@
-import type { Repository } from '../../../core/repository.js';
-import type { LogLevel } from '../../../utils/logger.js';
-import type { PackageFilterOptions } from '../../../utils/package-filter.js';
+import type { Repository } from '../../../../core/classes/repository.js';
+import type { LogLevel } from '../../../../utils/logger.js';
+import type { PackageFilterOptions } from '../../../../utils/package-filter.js';
 export declare namespace CleanService {
     interface Options extends PackageFilterOptions {
         /** Show the live progress panel. Default true; auto-disabled when stdout isn't a TTY. */

package/{plugins → builtins/platforms}/node/services/clean.service.js

@@ -2,9 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import colors from 'ansi-colors';
 import fg from 'fast-glob';
-import { Logger, resolveRootLogLevel } from '../../../utils/logger.js';
-import { filterPackages } from '../../../utils/package-filter.js';
-import { ProgressPanel } from '../../../utils/progress-panel.js';
+import { Logger, resolveRootLogLevel } from '../../../../utils/logger.js';
+import { filterPackages } from '../../../../utils/package-filter.js';
+import { ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CleanService;
 (function (CleanService) {
     /**

package/{plugins → builtins/platforms}/node/services/publish.service.d.ts

@@ -1,7 +1,7 @@
-import type { Package } from '../../../core/package.js';
-import type { Repository } from '../../../core/repository.js';
-import type { PackageFilterOptions } from '../../../utils/package-filter.js';
-import { type NpmPackageView } from '../utils/npm-view.js';
+import type { Package } from '../../../../core/classes/package.js';
+import type { Repository } from '../../../../core/classes/repository.js';
+import type { PackageFilterOptions } from '../../../../utils/package-filter.js';
+import { type NpmPackageView } from '../../../publish-targets/npm/npm-view.js';
 import { CiService } from './ci.service.js';
 export declare namespace PublishService {
     /** Injectable registry lookup - mainly for tests, so they don't depend on network access or a

package/{plugins → builtins/platforms}/node/services/publish.service.js

@@ -16,12 +16,12 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { exec } from '../../../utils/exec.js';
-import { GitHelper } from '../../../utils/git.js';
-import { filterPackages } from '../../../utils/package-filter.js';
-import { isCalendarVersion } from '../../../utils/release-version.js';
+import { exec } from '../../../../utils/exec.js';
+import { GitHelper } from '../../../../utils/git.js';
+import { filterPackages } from '../../../../utils/package-filter.js';
+import { isCalendarVersion } from '../../../../utils/release-version.js';
+import { npmViewPackage } from '../../../publish-targets/npm/npm-view.js';
 import { DEPENDENCY_KEYS } from '../node-manifest.provider.js';
-import { npmViewPackage } from '../utils/npm-view.js';
 import { parseWorkspaceRange, resolveWorkspaceRange } from '../utils/workspace-range.js';
 import { CiService } from './ci.service.js';
 function preparePublishManifest(pkg, publishDir, packagesByName) {
@@ -72,8 +72,14 @@ function preparePublishManifest(pkg, publishDir, packagesByName) {
  *   builds a native module on install. The rest (`build`, `test`, `prepare`, ...) never reach the
  *   consumer - `prepare` runs for a git dependency, which builds from the repository, not from this
  *   tarball.
- * - `private` - rman refuses to publish a private package in the first place, so carrying the flag
- *   into a manifest that is being published can only be wrong.
+ * - `private` - it is a statement about the **source tree**, not about the artifact derived from it,
+ *   and a manifest being published is by definition not private. rman's own gate normally stops a
+ *   private package before this runs, so the line looks unreachable; it is not, because `private`
+ *   is also how a repository keeps a stray `npm publish` out of the package directory while
+ *   publishing `build/` on purpose. That is a real configuration - this repository ran it until
+ *   `rman publish` became its own release path and the gate started refusing the thing it ships.
+ *   A narrower guard (`prepublishOnly`, which never reaches a consumer either) says the same thing
+ *   without claiming the artifact is unpublishable.
  * - `publishConfig.directory` - it pointed *here*; kept, it would point one level deeper again.
  */
 function derivePublishManifest(pkg, packagesByName) {

package/{plugins → builtins/platforms}/node/services/version-plan.service.d.ts

@@ -1,6 +1,6 @@
-import type { Package } from '../../../core/package.js';
-import { VersionPlanService } from '../../../services/version-plan.service.js';
-import type { GitHelper } from '../../../utils/git.js';
+import type { Package } from '../../../../core/classes/package.js';
+import { VersionPlanService } from '../../../../services/version-plan.service.js';
+import type { GitHelper } from '../../../../utils/git.js';
 /**
  * How a release is planned for an npm repository.
  *

package/{plugins → builtins/platforms}/node/services/version-plan.service.js

@@ -1,5 +1,5 @@
-import { ChangeHashService } from '../../../services/change-hash.service.js';
-import { VersionPlanService } from '../../../services/version-plan.service.js';
+import { ChangeHashService } from '../../../../services/change-hash.service.js';
+import { VersionPlanService } from '../../../../services/version-plan.service.js';
 /**
  * How a release is planned for an npm repository.
  *

package/builtins/presets/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * **Where the presets are.** `ConfigReader` resolves `extends: "rman:<name>"` against this.
+ */
+export declare const PRESETS_DIR: string;
+/** Every preset rman ships, read off the directory rather than written down again. */
+export declare function presetNames(): string[];
+/**
+ * **The presets rman ships, laid underneath every repository's own config.**
+ *
+ * A repository writing nothing at all still gets these, exactly as if its `.rmanrc` had opened with
+ * `extends: ['rman:node']` - so `rman list` finds the workspace and `rman clean` exists without a
+ * config file having to say so. A repository naming one itself changes nothing: the key appends, and
+ * a technology already present by name is skipped.
+ */
+export declare const DEFAULT_PRESETS: readonly string[];

package/builtins/presets/index.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * **Where the presets are.** `ConfigReader` resolves `extends: "rman:<name>"` against this.
+ */
+/* **The directory says where it is, rather than the reader computing a path to it.** It was
+ * `path.resolve(dirname(config-reader), '..', 'presets')` - two relative hops between two files
+ * that nothing keeps in step, and moving either one breaks it silently at *runtime*: measured, the
+ * `core/config/` + `builtins/presets/` reorganization left every repository answering
+ * `"presets" has no preset "node". rman ships: node.` - a message that named the preset it had
+ * just failed to find, because the list behind it was a hardcoded `['node']` somewhere else again.
+ * `tsc` cannot see a path built with `path.resolve`, so only a run says. */
+export const PRESETS_DIR = path.dirname(fileURLToPath(import.meta.url));
+/** Every preset rman ships, read off the directory rather than written down again. */
+/* One `readdirSync`, on an error path only - `_resolvePreset` asks after a lookup already failed.
+ * Reading the directory is what keeps the message true: the hardcoded list it replaces could say
+ * `node` while `node.js` was not where the resolver looked. `index` is this file. */
+export function presetNames() {
+    try {
+        return [
+            ...new Set(fs
+                .readdirSync(PRESETS_DIR)
+                .filter(f => /\.(js|ts)$/.test(f) && !/\.d\.ts$/.test(f))
+                .map(f => f.replace(/\.(js|ts)$/, ''))
+                .filter(n => n !== 'index')),
+        ].sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * **The presets rman ships, laid underneath every repository's own config.**
+ *
+ * A repository writing nothing at all still gets these, exactly as if its `.rmanrc` had opened with
+ * `extends: ['rman:node']` - so `rman list` finds the workspace and `rman clean` exists without a
+ * config file having to say so. A repository naming one itself changes nothing: the key appends, and
+ * a technology already present by name is skipped.
+ */
+/* **Names, not imports, and that is load-bearing rather than tidy.** A preset's module pulls in a
+ * platform, its commands and its services, and one of those services extends a core service - so a
+ * static import from `core/` closes the cycle that stopped the *built* CLI dead on every command
+ * (`Cannot access 'VersionPlanService' before initialization`, invisible to the suite, which is why
+ * `npm run smoke` exists). `ConfigReader` resolves these through the same dynamic `import()` an
+ * `extends: "rman:node"` goes through, so this file stays a list of strings and imports nothing.
+ *
+ * **This replaced detection**, which asked each built-in "is this directory yours?" before turning
+ * anything on, and merged the matching preset underneath. What that bought was a repository not
+ * growing a technology's commands unasked; what it cost was a catalogue module, a `Builtin` type, a
+ * per-directory memo and a gate that had to decide what counts as having "said something". The
+ * platform answers the same question now - `manifestProvider.read` is what detection asked - and it
+ * answers it from the ordinary registry, once loaded. The cost, stated rather than hidden: a
+ * repository of some other technology carries node's `clean` and `ci` in `rman --help`, and
+ * `rman info` reports npm's tooling. Split this list's presets in two - the platform apart from the
+ * commands - if that ever stops being acceptable. */
+export const DEFAULT_PRESETS = ['node'];

package/builtins/presets/node.d.ts

@@ -0,0 +1,16 @@
+import type { RmanConfig } from '../../interfaces/rman-config.interface.js';
+/**
+ * **The `node` preset** - everything rman knows about the npm ecosystem, as a config.
+ *
+ * ```yaml
+ * # .rmanrc.yml
+ * extends: node
+ * ```
+ *
+ * It contributes the technology (how a `package.json` is read, where `workspaces` point, how
+ * versions are planned), the two commands that are npm's alone (`clean`, `ci`), and the `npm`
+ * publish target. A polyglot repository names several: `extends: ['node', 'cargo']` holds both,
+ * because every key here appends.
+ */
+export declare function nodePreset(): RmanConfig;
+export default nodePreset;

package/builtins/presets/node.js

@@ -0,0 +1,57 @@
+import { definePlatform } from '../../core/interfaces/plugin.js';
+import { defineConfig } from '../../interfaces/rman-config.interface.js';
+import { augmentSystemInfo, ciCommand, cleanCommand, NodePlatform } from '../platforms/node/index.js';
+import { NpmPublishTarget } from '../publish-targets/npm/index.js';
+/**
+ * **The `node` preset** - everything rman knows about the npm ecosystem, as a config.
+ *
+ * ```yaml
+ * # .rmanrc.yml
+ * extends: node
+ * ```
+ *
+ * It contributes the technology (how a `package.json` is read, where `workspaces` point, how
+ * versions are planned), the two commands that are npm's alone (`clean`, `ci`), and the `npm`
+ * publish target. A polyglot repository names several: `extends: ['node', 'cargo']` holds both,
+ * because every key here appends.
+ */
+/* **A config rather than a plugin, and that is the whole shape of a preset.** `commands` and
+ * `publishTargets` were already config keys; `platforms` is one now, so a technology arrives the
+ * same way everything else does. What used to need a `Builtin` type, a name that looked like a glob
+ * and an expansion step is `extends` and nothing else.
+ *
+ * **A function, so nothing here happens until a repository asks for it.** `augmentSystemInfo()`
+ * mutates the core's own `SystemInfo` in place, so running it at import time would have `rman info`
+ * report npm's tooling in a Cargo repository that never named this preset. `extends` imports the
+ * module it names and calls this; a repository that names something else never reaches it. */
+export function nodePreset() {
+    augmentSystemInfo();
+    return defineConfig({
+        platforms: [(nodePlatform ??= definePlatform(new NodePlatform()))],
+        commands: [ciCommand, cleanCommand],
+        publishTargets: [(npmTarget ??= new NpmPublishTarget())],
+    });
+}
+export default nodePreset;
+/**
+ * **One instance of each across every call, so calling this preset twice contributes one of each.**
+ *
+ * A repository writing `extends: 'rman:node'` is read *and* gets the same preset laid under it by
+ * default, which is ordinary rather than a mistake - the contribution keys append and drop a
+ * duplicate **by identity** (`appendList`). The two commands are module consts, so they dedup on
+ * their own; anything this factory `new`s does not, and both of these have been that at some point.
+ *
+ * - **The target announced itself loudly.** Two of them reached `publish`, which refuses two
+ *   targets declaring one option name, and it died with `Publish targets "npm" and "npm" both
+ *   declare an option named "packageManager"` - the guard working exactly as intended, on a
+ *   collision with itself.
+ * - **The platform does not, and that is the one to watch.** `_addPlatform` dedups by *name*, so a
+ *   second `node` platform never reaches `context.platforms` and nothing resolves differently. What
+ *   it does is put the same technology in `config.platforms` twice - visible only in `rman config`
+ *   and to whoever iterates the key - plus an `augmentSystemInfo()` and a `new NodePlatform()` per
+ *   read. Caught by the identity spec in `docs-api.spec.ts` rather than by anything failing.
+ *
+ * **A new preset has to do the same for anything it constructs.**
+ */
+let npmTarget;
+let nodePlatform;

package/{services → builtins/publish-targets/docker}/docker-publish.service.d.ts

@@ -1,11 +1,11 @@
-import { type PublishTarget } from '../core/publish-target.js';
-import { Service } from '../core/service.js';
-import { type PackageFilterOptions } from '../utils/package-filter.js';
+import { Service } from '../../../core/classes/service.js';
+import { type PublishTarget } from '../../../core/interfaces/publish-target.js';
+import { type PackageFilterOptions } from '../../../utils/package-filter.js';
 /**
  * The name this target answers to in `publish.target` and `--target`.
  *
  * Declared beside the implementation rather than in `publish-target.ts`: the seam is general and
- * must not know any one target's name, and the adapter in `targets/docker.target.ts` reads it from
+ * must not know any one target's name, and the adapter in `builtins/publish-targets/docker/docker.target.ts` reads it from
  * here, which keeps the dependency pointing one way.
  */
 export declare const DOCKER_TARGET = "docker";
@@ -31,7 +31,7 @@ export declare class DockerPublishService extends Service {
     /**
      * Publishes every `'publish'` entry in `plan`: one `docker login` and one `docker buildx create`
      * up front (each package's own build reuses them), then per package a single `docker buildx
-     * build --push` using that package's `publish.docker` config (platforms, named build-contexts,
+     * build --push` using that package's `publish.docker` config (architectures, named build-contexts,
      * build-args, an optional `cwd` override). A package's `publish.docker.readme` file (default
      * `DOCKER_README.md`), if present, updates the DockerHub repo description afterward. A package's
      * own failure doesn't stop unrelated packages elsewhere in the plan.
@@ -66,7 +66,7 @@ export declare namespace DockerPublishService {
         image?: string;
     }
 }
-declare module '../core/service.js' {
+declare module '../../../core/classes/service.js' {
     interface ServiceMap {
         dockerPublish: DockerPublishService;
     }

package/{services → builtins/publish-targets/docker}/docker-publish.service.js

@@ -2,16 +2,16 @@ import { execFile } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { targetsOf } from '../core/publish-target.js';
-import { Service } from '../core/service.js';
-import { exec } from '../utils/exec.js';
-import { GitHelper } from '../utils/git.js';
-import { filterPackages } from '../utils/package-filter.js';
+import { Service } from '../../../core/classes/service.js';
+import { targetsOf } from '../../../core/interfaces/publish-target.js';
+import { exec } from '../../../utils/exec.js';
+import { GitHelper } from '../../../utils/git.js';
+import { filterPackages } from '../../../utils/package-filter.js';
 /**
  * The name this target answers to in `publish.target` and `--target`.
  *
  * Declared beside the implementation rather than in `publish-target.ts`: the seam is general and
- * must not know any one target's name, and the adapter in `targets/docker.target.ts` reads it from
+ * must not know any one target's name, and the adapter in `builtins/publish-targets/docker/docker.target.ts` reads it from
  * here, which keeps the dependency pointing one way.
  */
 export const DOCKER_TARGET = 'docker';
@@ -94,7 +94,7 @@ export class DockerPublishService extends Service {
     /**
      * Publishes every `'publish'` entry in `plan`: one `docker login` and one `docker buildx create`
      * up front (each package's own build reuses them), then per package a single `docker buildx
-     * build --push` using that package's `publish.docker` config (platforms, named build-contexts,
+     * build --push` using that package's `publish.docker` config (architectures, named build-contexts,
      * build-args, an optional `cwd` override). A package's `publish.docker.readme` file (default
      * `DOCKER_README.md`), if present, updates the DockerHub repo description afterward. A package's
      * own failure doesn't stop unrelated packages elsewhere in the plan.
@@ -172,10 +172,10 @@ async function dockerLogin(app, cwd) {
 async function buildAndPush(repository, entry) {
     const pkg = entry.package;
     const docker = pkg.config.publish.docker;
-    const platforms = docker.platforms?.length ? docker.platforms : ['linux/amd64'];
+    const architectures = docker.architectures?.length ? docker.architectures : ['linux/amd64'];
     const dockerfile = path.resolve(pkg.dirname, docker.dockerfile || 'Dockerfile');
     const cwd = docker.cwd ? path.resolve(repository.dirname, docker.cwd) : pkg.dirname;
-    const args = ['buildx', 'build', '--platform', platforms.join(',')];
+    const args = ['buildx', 'build', '--platform', architectures.join(',')];
     for (const [name, dir] of Object.entries(docker.buildContexts ?? {})) {
         args.push('--build-context', `${name}="${path.resolve(pkg.dirname, dir)}"`);
     }