rman 2.13.0 → 2.15.0

package/commands/deps.command.d.ts

@@ -0,0 +1,175 @@
+import type { RmanApplication } from '../core/application.js';
+import { type RmanConfig } from '../interfaces/rman-config.interface.js';
+/** Hoisted for `ArgsOf` - see `version.command.ts` and `RmanConfig.ArgsOf` for why. */
+declare const COMMAND: "deps [names..]";
+declare const config: {
+    scope: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    ignore: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    platform: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    upgrade: {
+        target: "cli";
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    /** Its `choices` and its default are the version schemes' own sizes, so they are filled in where
+     *  the command is built - see `targetOption`. */
+    target: {
+        target: "both";
+        describe: string;
+        type: "string";
+    };
+    reject: {
+        target: "both";
+        describe: string;
+        type: "string";
+        array: true;
+    };
+    minAge: {
+        target: "both";
+        cliName: string;
+        describe: string;
+        type: "number";
+    };
+    types: {
+        target: "config";
+        describe: string;
+        type: "string";
+        array: true;
+    };
+    concurrency: {
+        target: "cli";
+        describe: string;
+        type: "number";
+    };
+    verify: {
+        target: "cli";
+        describe: string;
+        type: "boolean";
+    };
+    json: {
+        target: "cli";
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+};
+type Args = RmanConfig.ArgsOf<typeof config, typeof COMMAND>;
+/**
+ * `rman deps` - which dependencies have a newer version, and with `--upgrade`, moving them there.
+ *
+ * A version is offered only when every rule that can be seen allows it: the package's own
+ * `deps.target`/`reject`/`minAge`, the peer ranges of the other dependencies it names, the runtime
+ * the package supports, and what its sibling packages ask of a shared dependency. Each version held
+ * back is printed with the rule that held it.
+ */
+declare const depsCommand: (app: RmanApplication) => {
+    command: "deps [names..]";
+    describe: string;
+    config: {
+        target: {
+            target: "both";
+            describe: string;
+            type: "string";
+        } & {
+            choices: string[];
+        };
+        scope: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        ignore: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        platform: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        upgrade: {
+            target: "cli";
+            alias: string;
+            describe: string;
+            type: "boolean";
+        };
+        reject: {
+            target: "both";
+            describe: string;
+            type: "string";
+            array: true;
+        };
+        minAge: {
+            target: "both";
+            cliName: string;
+            describe: string;
+            type: "number";
+        };
+        types: {
+            target: "config";
+            describe: string;
+            type: "string";
+            array: true;
+        };
+        concurrency: {
+            target: "cli";
+            describe: string;
+            type: "number";
+        };
+        verify: {
+            target: "cli";
+            describe: string;
+            type: "boolean";
+        };
+        json: {
+            target: "cli";
+            alias: string;
+            describe: string;
+            type: "boolean";
+        };
+    };
+    positionals: {
+        names: {
+            describe: string;
+            type: "string";
+        };
+    };
+    examples: {
+        command: string;
+        description: string;
+    }[];
+    handler: (args: Args) => Promise<void>;
+};
+export default depsCommand;
+/** The rest of `deps.*` - what an option cannot describe. */
+export interface DepsExtraKeys {
+    /**
+     * The largest move for the dependencies a glob matches, ahead of `target` - a package that
+     * releases a major every few weeks, or one that has stayed on `0.x` for years, where a `0.x`
+     * minor counts as a major. The last glob matching a name wins.
+     *
+     * @example { "@types/node": "major", "esbuild": "major" }
+     */
+    targets?: Record<string, string>;
+}
+/** `deps`'s own keys on `RmanConfig`: derived from the `config` block, plus `DepsExtraKeys`. */
+declare module '../interfaces/rman-config.interface.js' {
+    namespace RmanConfig {
+        interface CommandConfigs extends RmanConfig.CommandContribution<ReturnType<typeof depsCommand>, DepsExtraKeys> {
+        }
+    }
+}

package/commands/deps.command.js

@@ -0,0 +1,252 @@
+import path from 'node:path';
+import colors from 'ansi-colors';
+import { semverScheme } from '../core/classes/version-scheme.js';
+import { DependencyUpdater } from '../core/interfaces/dependency-updater.js';
+import { registerCommand } from '../interfaces/rman-config.interface.js';
+import { filterPackages, packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+/** Hoisted for `ArgsOf` - see `version.command.ts` and `RmanConfig.ArgsOf` for why. */
+const COMMAND = 'deps [names..]';
+const { scope, ignore, platform } = packageFilterOptions;
+const config = {
+    /* `--deps`/`--dependents` are left out: on a command called `deps`, `rman deps --deps` would read
+     * as something other than "and the packages these depend on". */
+    scope,
+    ignore,
+    platform,
+    upgrade: {
+        target: 'cli',
+        alias: 'u',
+        describe: 'Write the new ranges to the manifests, then check that they still install',
+        type: 'boolean',
+    },
+    /** Its `choices` and its default are the version schemes' own sizes, so they are filled in where
+     *  the command is built - see `targetOption`. */
+    target: {
+        target: 'both',
+        describe: 'The largest move a dependency may make',
+        type: 'string',
+    },
+    reject: {
+        target: 'both',
+        describe: 'Leave the dependencies matching these globs alone (repeatable)',
+        type: 'string',
+        array: true,
+    },
+    minAge: {
+        target: 'both',
+        cliName: 'min-age',
+        describe: 'Only move to a version published at least this many days ago',
+        type: 'number',
+    },
+    types: {
+        target: 'config',
+        describe: "The dependency kinds to look at, in the ecosystem's own words - default: every kind",
+        type: 'string',
+        array: true,
+    },
+    concurrency: {
+        target: 'cli',
+        describe: `How many registry lookups run at once (default: ${defaultConcurrency()})`,
+        type: 'number',
+    },
+    verify: {
+        target: 'cli',
+        describe: "After --upgrade, ask the ecosystem's own resolver whether the result installs (default: true)",
+        type: 'boolean',
+    },
+    json: {
+        target: 'cli',
+        alias: 'j',
+        describe: 'Print the plan as JSON - one entry per package and dependency',
+        type: 'boolean',
+    },
+};
+/**
+ * `rman deps` - which dependencies have a newer version, and with `--upgrade`, moving them there.
+ *
+ * A version is offered only when every rule that can be seen allows it: the package's own
+ * `deps.target`/`reject`/`minAge`, the peer ranges of the other dependencies it names, the runtime
+ * the package supports, and what its sibling packages ask of a shared dependency. Each version held
+ * back is printed with the rule that held it.
+ */
+/* **The command is the core's and the answer is the technology's** - see `DependencyUpdater`. A
+ * package whose platform has no updater is left alone, which in a polyglot repository is the right
+ * answer for the half rman cannot speak for. */
+const depsCommand = registerCommand(app => {
+    const repository = app.repository;
+    return {
+        command: COMMAND,
+        describe: 'Lists the dependencies that have a newer version - pass -u to upgrade them',
+        config: { ...config, target: targetOption(app) },
+        positionals: {
+            names: { describe: 'Only these dependencies (globs)', type: 'string' },
+        },
+        examples: [
+            { command: '$0 deps', description: '# What could move, and what holds it back' },
+            { command: '$0 deps -u', description: '# Write the new ranges, then check that they install' },
+            { command: '$0 deps --target major', description: '# Across a major too' },
+            { command: '$0 deps "@types/*"', description: '# Only the dependencies matching this glob' },
+        ],
+        handler: async (args) => {
+            const options = {
+                names: args.names?.length ? args.names.map(String) : undefined,
+                target: args.target,
+                reject: args.reject?.map(String),
+                minAge: args.minAge,
+                concurrency: Math.max(1, args.concurrency ?? defaultConcurrency()),
+            };
+            const ctx = { app, repository, options };
+            /** The root holds a monorepo's shared tooling, so it is asked too. */
+            const candidates = repository.monorepo ? [repository.rootPackage, ...repository.packages] : repository.packages;
+            const selected = filterPackages([...candidates], readPackageFilterOptions(args));
+            if (!selected.length)
+                throw logged('No package matched.');
+            const byUpdater = new Map();
+            for (const pkg of selected) {
+                const updater = pkg.platform.dependencyUpdater;
+                if (!updater)
+                    continue;
+                byUpdater.set(updater, [...(byUpdater.get(updater) ?? []), pkg]);
+            }
+            if (!byUpdater.size) {
+                throw logged('None of the selected packages belongs to a technology that can update its dependencies.');
+            }
+            const plans = new Map();
+            for (const [updater, packages] of byUpdater)
+                plans.set(updater, await updater.getPlan(ctx, packages));
+            const all = [...plans.values()].flat();
+            if (args.json)
+                console.log(JSON.stringify(jsonPlan(all), undefined, 2));
+            else
+                printPlan(all, repository.dirname);
+            const errors = all.filter(e => e.status === 'error');
+            const updates = all.filter(e => e.status === 'update');
+            if (!args.upgrade) {
+                if (updates.length && !args.json)
+                    console.log(colors.gray('\nRun "rman deps -u" to upgrade.'));
+                if (errors.length)
+                    throw logged(`${errors.length} dependency lookup(s) failed - see above.`);
+                return;
+            }
+            const applied = [];
+            for (const [updater, plan] of plans) {
+                if (plan.some(e => e.status === 'update'))
+                    applied.push(await updater.applyPlan(ctx, plan));
+            }
+            const files = applied.flatMap(a => a.files);
+            if (files.length && args.verify !== false) {
+                for (const [updater, packages] of byUpdater) {
+                    const refused = await updater.verify?.(ctx, packages);
+                    if (!refused)
+                        continue;
+                    for (const a of applied)
+                        a.restore();
+                    throw logged(`The upgraded manifests do not install, so they were put back:\n${refused}`);
+                }
+            }
+            if (!args.json) {
+                for (const file of files)
+                    console.log(colors.green('updated'), path.relative(repository.dirname, file));
+            }
+            if (errors.length)
+                throw logged(`${errors.length} dependency lookup(s) failed - see above.`);
+        },
+    };
+});
+export default depsCommand;
+/** Registry lookups are child processes waiting on the network, not CPU work, so the default is a
+ *  fixed number rather than the core count. */
+function defaultConcurrency() {
+    return 16;
+}
+/**
+ * `--target`: one of the version schemes' sizes, and by default every size but the largest.
+ *
+ * Read off the technologies this repository loaded rather than written down, because the sizes are
+ * a scheme's - semver's three are the only ones today.
+ */
+function targetOption(app) {
+    const schemes = [...app.platforms].map(p => p.manifestProvider.versionScheme ?? semverScheme);
+    const sizes = [...new Set((schemes.length ? schemes : [semverScheme]).flatMap(s => s.bumpNames))];
+    const defaults = [...new Set(schemes.map(s => DependencyUpdater.defaultTarget(s.bumpNames)))];
+    return {
+        ...config.target,
+        describe: `${config.target.describe} (default: ${defaults.join(' / ') || DependencyUpdater.defaultTarget(semverScheme.bumpNames)})`,
+        choices: sizes,
+    };
+}
+function jsonPlan(entries) {
+    return entries.map(e => ({
+        package: e.package.name,
+        name: e.name,
+        types: e.types,
+        status: e.status,
+        current: e.current,
+        target: e.target,
+        latest: e.latest,
+        available: e.available,
+        bump: e.bump,
+        reason: e.reason,
+    }));
+}
+/**
+ * One block per package with something to say: what moves, grouped by size, smallest first - and
+ * then **what does not**, each with the reason it stays.
+ */
+/* **The second half is the one `npm-check-updates` taught people to read.** Under `--target minor`
+ * a major that was left behind has to be on the screen, or a run reporting three patches looks like
+ * a repository that is current. A dependency that moved but not as far as it could appears in both:
+ * once under its size, once under "not updated" with what held it. */
+function printPlan(entries, root) {
+    const updated = entries.filter(e => e.status === 'update');
+    const behind = entries.filter(e => e.status === 'held' || e.status === 'skipped' || e.status === 'error' || (e.status === 'update' && e.reason));
+    if (!updated.length && !behind.length) {
+        console.log(colors.gray('Every dependency is up to date.'));
+        return;
+    }
+    const shown = [...updated, ...behind];
+    const nameWidth = Math.max(...shown.map(e => e.name.length));
+    const currentWidth = Math.max(...shown.map(e => e.current.length));
+    const row = (e, rest) => `    ${e.name.padEnd(nameWidth)}  ${e.current.padEnd(currentWidth)}  ${rest}`;
+    for (const pkg of [...new Set(shown.map(e => e.package))]) {
+        const where = path.relative(root, pkg.dirname);
+        console.log(colors.cyan(pkg.name) + (where ? colors.gray(` (${where})`) : ''));
+        const sizes = pkg.versionScheme.bumpNames;
+        for (const size of [...sizes, undefined]) {
+            const group = updated.filter(e => e.package === pkg && (size ? e.bump === size : !sizes.includes(e.bump)));
+            if (!group.length)
+                continue;
+            const paint = sizeColor(size, sizes);
+            console.log(`  ${paint(size ?? 'other')}`);
+            for (const e of group)
+                console.log(row(e, `→  ${paint(e.target ?? '')}`));
+        }
+        const left = behind.filter(e => e.package === pkg);
+        if (!left.length)
+            continue;
+        console.log(`  ${colors.yellow('not updated')}`);
+        const newest = (e) => (e.status === 'error' ? 'error' : (e.available ?? e.latest ?? ''));
+        const width = Math.max(...left.map(e => newest(e).length));
+        for (const e of left) {
+            const paint = e.status === 'error' ? colors.red : (text) => text;
+            console.log(row(e, `${paint(newest(e).padEnd(width))}  ${colors.gray(e.reason ?? '')}`));
+        }
+    }
+}
+/** The colours `npm-check-updates` uses - the largest size red, the next cyan, the rest green - read
+ *  off the scheme's own order so a scheme with other names still gets them. */
+function sizeColor(size, sizes) {
+    const rank = size ? sizes.indexOf(size) : -1;
+    if (rank === sizes.length - 1)
+        return colors.red;
+    if (rank === sizes.length - 2)
+        return colors.cyan;
+    return colors.green;
+}
+/** The `logged` convention: printed here, so `runCli`'s catch does not print it a second time. */
+function logged(message) {
+    console.error(colors.red(message));
+    const err = new Error(message);
+    err.logged = true;
+    return err;
+}

package/commands/info.command.js

@@ -60,13 +60,19 @@ function printSystemInfo(systemInfo) {
 }
 function printRepositoryInfo(info) {
     console.log('', colors.whiteBright('Repository') + ':');
-    console.log('    ' + colors.reset('Type') + '     :', colors.yellowBright(info.type === 'monorepo' ? 'Monorepo' : 'Single package'));
-    console.log('    ' + colors.reset('Name') + '     :', colors.yellowBright(info.name || '(none)'));
-    console.log('    ' + colors.reset('Version') + '  :', colors.yellowBright(info.version || '(none)'));
-    console.log('    ' + colors.reset('Root') + '     :', colors.yellowBright(info.root));
+    const rows = [
+        ['Type', colors.yellowBright(info.type === 'monorepo' ? 'Monorepo' : 'Single package')],
+        ['Name', colors.yellowBright(info.name || '(none)')],
+        ['Version', colors.yellowBright(info.version || '(none)')],
+        ['Root', colors.yellowBright(info.root)],
+        ['Platforms', colors.yellowBright(info.platforms.join(', ') || '(none)')],
+    ];
     if (info.type === 'monorepo') {
-        console.log('    ' + colors.reset('Packages') + ' :', colors.yellowBright(String(info.packageCount)), colors.gray('(run "list" to see them)'));
+        rows.push(['Packages', colors.yellowBright(String(info.packageCount)), colors.gray('(run "list" to see them)')]);
     }
+    const width = Math.max(...rows.map(([label]) => label.length));
+    for (const [label, ...values] of rows)
+        console.log('    ' + colors.reset(label.padEnd(width)) + ' :', ...values);
 }
 /**
  * `rman info` - environment and repository, and back in the core because most of what it reports

package/commands/version.command.js

@@ -210,6 +210,8 @@ const versionCommand = registerCommand(app => {
                     name: e.package.name,
                     selector: e.package.selector,
                     isRoot: e.package.isRoot,
+                    /** `rman list --json`'s spelling, so a consumer joins the two on it. */
+                    groupKey: e.groupKey,
                     group: e.group,
                     status: e.status,
                     from: e.from,

package/commands.d.ts

@@ -15,6 +15,7 @@
 import './commands/build.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
+import './commands/deps.command.js';
 import './commands/diff.command.js';
 import './commands/exec.command.js';
 import './commands/github-release.command.js';
@@ -27,5 +28,6 @@ import './commands/test.command.js';
 import './commands/version.command.js';
 /** The config shapes a command declares by hand, where an option cannot describe them - see
  *  `RmanConfig.CommandContribution`'s `Extra`. Exported so a plugin can name one. */
+export type { DepsExtraKeys } from './commands/deps.command.js';
 export type { PublishExtraKeys, PublishTargetConfigs } from './commands/publish.command.js';
 export type { VersionExtraKeys, VersionStampEntry } from './commands/version.command.js';

package/commands.js

@@ -15,6 +15,7 @@
 import './commands/build.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
+import './commands/deps.command.js';
 import './commands/diff.command.js';
 import './commands/exec.command.js';
 import './commands/github-release.command.js';

package/constants.js

@@ -1 +1 @@
-export const version = '2.13.0';
+export const version = '2.15.0';

package/core/interfaces/dependency-updater.d.ts

@@ -0,0 +1,114 @@
+import type { RmanApplication } from '../application.js';
+import type { Package } from '../classes/package.js';
+import type { Repository } from '../classes/repository.js';
+/**
+ * **How one technology answers "are this package's dependencies current, and what may they move
+ * to"** - the half of `rman deps` that is an ecosystem's.
+ *
+ * The command owns the repository's half: which packages are asked, printing the plan, `--json`,
+ * writing only under `--upgrade`, and undoing the writes when `verify` refuses them.
+ */
+export interface DependencyUpdater {
+    /** What each dependency of `packages` would move to - never writes. */
+    getPlan(ctx: DependencyUpdater.Context, packages: readonly Package[]): Promise<DependencyUpdater.Entry[]>;
+    /** Writes every `'update'` entry of `plan` to its manifest, and returns how to take that back. */
+    applyPlan(ctx: DependencyUpdater.Context, plan: readonly DependencyUpdater.Entry[]): Promise<DependencyUpdater.Applied>;
+    /**
+     * Asks the ecosystem's own resolver whether the manifests as they now stand can be installed,
+     * once `applyPlan` has written them. Returns why not, or `undefined` when they can.
+     *
+     * Omit it when the ecosystem has no resolver to ask; the plan's own checks then stand alone.
+     */
+    verify?(ctx: DependencyUpdater.Context, packages: readonly Package[]): Promise<string | undefined>;
+}
+export declare namespace DependencyUpdater {
+    /** What one call is handed. */
+    interface Context {
+        readonly app: RmanApplication;
+        readonly repository: Repository;
+        readonly options: Options;
+    }
+    /** The run's own settings, read off the command line. A package's `.rmanrc "deps"` block supplies
+     *  the rest - see `settingsFor`. */
+    interface Options {
+        /** Only the dependencies whose names match one of these globs. */
+        names?: string[];
+        /** Overrides every package's `deps.target`. */
+        target?: string;
+        /** Added to every package's `deps.reject`. */
+        reject?: string[];
+        /** Overrides every package's `deps.minAge`. */
+        minAge?: number;
+        /** How many registry lookups run at once. */
+        concurrency: number;
+        /** Reported as each dependency name's registry lookup finishes. */
+        onProgress?(done: number, total: number): void;
+    }
+    /** One package's settings, once the command line has been laid over its config. */
+    interface Settings {
+        /** The largest move allowed, as one of the package's version scheme's `bumpNames` - `minor`
+         *  keeps every dependency inside its major. */
+        target: string;
+        /** `deps.targets`: a dependency-name glob, and the largest move for the names it matches -
+         *  ahead of `target`. Empty when `--target` was given, which overrides both. */
+        targets: Record<string, string>;
+        reject: string[];
+        minAge: number;
+        /** The dependency kinds to look at, in the ecosystem's own words - `undefined` is every one. */
+        types?: string[];
+    }
+    /**
+     * One dependency of one package.
+     *
+     * - `'update'`: `target` is the new range; `reason` says why it is lower than `latest`, if it is.
+     * - `'held'`: a newer version exists and is allowed, but another dependency's rule refuses it -
+     *   `reason` names that rule.
+     * - `'skipped'`: a newer version exists, and the package's own settings leave it out - a major
+     *   under `target: minor`, or one younger than `minAge`. `reason` says which.
+     * - `'up-to-date'`: nothing newer exists.
+     * - `'error'`: the registry gave no answer.
+     */
+    interface Entry {
+        package: Package;
+        /** The dependency's name. */
+        name: string;
+        /** Where the package declares it, in the ecosystem's own words - `devDependencies`. */
+        types: string[];
+        /** The range as the manifest declares it. */
+        current: string;
+        status: 'update' | 'held' | 'skipped' | 'up-to-date' | 'error';
+        /** The range it is rewritten to, on an `'update'`. */
+        target?: string;
+        /** The newest version the package's own settings allow, before any other dependency's rule. */
+        latest?: string;
+        /** The newest version there is, whatever the settings say - what a reader compares against to
+         *  see what was left behind. */
+        available?: string;
+        /** How far `target` moves, in the version scheme's own words - `major`. */
+        bump?: string;
+        reason?: string;
+    }
+    /** What `applyPlan` wrote. */
+    interface Applied {
+        /** Every file it changed, absolute. */
+        files: string[];
+        /** Puts every one of them back as it was. */
+        restore(): void;
+    }
+    /**
+     * Every move but the largest - `minor` under semver. The largest is the one a scheme reserves for a
+     * break, and taking a break is a decision a person makes, not a default.
+     */
+    function defaultTarget(bumps: readonly string[]): string;
+    /**
+     * The largest move `settings` allow for the dependency `name`, and the key that said so - the
+     * **last** `deps.targets` glob matching it, else `deps.target`.
+     */
+    function targetFor(settings: Settings, name: string): {
+        size: string;
+        from: string;
+    };
+    /** The settings `pkg` is planned with: `options` from the command line over its `.rmanrc "deps"`,
+     *  and the defaults under both. */
+    function settingsFor(pkg: Package, options: Options): Settings;
+}

package/core/interfaces/dependency-updater.js

@@ -0,0 +1,61 @@
+import micromatch from 'micromatch';
+export var DependencyUpdater;
+(function (DependencyUpdater) {
+    /**
+     * Every move but the largest - `minor` under semver. The largest is the one a scheme reserves for a
+     * break, and taking a break is a decision a person makes, not a default.
+     */
+    /* **It was `latest` - every move - and that was the wrong default**, measured the moment it ran:
+     * a `^5.3.0` came back as `^7.0.2`. The values are the scheme's own `bumpNames` rather than a list
+     * written here, for the reason `version` gives: `patch`/`minor`/`major` are semver's words, and a
+     * four-part scheme would offer four. */
+    function defaultTarget(bumps) {
+        return bumps[Math.max(0, bumps.length - 2)];
+    }
+    DependencyUpdater.defaultTarget = defaultTarget;
+    /**
+     * The largest move `settings` allow for the dependency `name`, and the key that said so - the
+     * **last** `deps.targets` glob matching it, else `deps.target`.
+     */
+    /* Last rather than first, because that is how two `"[selector]"` blocks layer: what is written
+     * later wins. */
+    function targetFor(settings, name) {
+        let found;
+        for (const [glob, size] of Object.entries(settings.targets)) {
+            if (micromatch.isMatch(name, glob))
+                found = { size, from: `deps.targets["${glob}"]` };
+        }
+        return found ?? { size: settings.target, from: 'deps.target' };
+    }
+    DependencyUpdater.targetFor = targetFor;
+    /** The settings `pkg` is planned with: `options` from the command line over its `.rmanrc "deps"`,
+     *  and the defaults under both. */
+    function settingsFor(pkg, options) {
+        const config = pkg.config.deps ?? {};
+        const bumps = pkg.versionScheme.bumpNames;
+        const target = options.target ?? config.target ?? defaultTarget(bumps);
+        if (!bumps.includes(target)) {
+            throw new Error(`Invalid "deps.target" for "${pkg.name}": "${target}" (expected one of: ${bumps.join(', ')}, ` +
+                `the "${pkg.versionScheme.name}" scheme's own sizes)`);
+        }
+        const targets = options.target ? {} : { ...(config.targets ?? {}) };
+        for (const [glob, size] of Object.entries(targets)) {
+            if (!bumps.includes(size)) {
+                throw new Error(`Invalid "deps.targets" entry "${glob}" for "${pkg.name}": "${size}" (expected one of: ${bumps.join(', ')})`);
+            }
+        }
+        return {
+            target,
+            targets,
+            reject: [...toList(config.reject), ...(options.reject ?? [])],
+            minAge: options.minAge ?? config.minAge ?? 0,
+            types: config.types?.length ? [...config.types] : undefined,
+        };
+    }
+    DependencyUpdater.settingsFor = settingsFor;
+})(DependencyUpdater || (DependencyUpdater = {}));
+function toList(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? [...value] : [value];
+}

package/core/interfaces/manifest.js

@@ -53,7 +53,7 @@ export var Manifest;
             }
         }
         throw new Error(`No manifest provider recognizes "${dir}", so there is nowhere to write its version.\n` +
-            `  A repository's ".rmanrc" names its technologies - see "plugins" (e.g. ['node']).`);
+            `  A repository's ".rmanrc" names its technologies - see "platforms", or "extends" (e.g. "rman:node").`);
     }
     Manifest.write = write;
     /**