rman 2.18.2 → 2.19.1

package/builtins/platforms/node/node-dependency-updater.d.ts

@@ -68,11 +68,17 @@ export declare class NodeDependencyUpdater implements DependencyUpdater {
     protected resolve(decisions: readonly NodeDependencyUpdater.Decision[], ctx: DependencyUpdater.Context): void;
     /** One broken rule, mended by one step down. Whether anything moved. */
     protected settle(about: NodeDependencyUpdater.Decision, stating: NodeDependencyUpdater.Decision | undefined, range: string, rule: string): boolean;
+    /** `rule`, plus why `about` cannot meet it when the version that would is one its own settings
+     *  leave out - `0.14.0: major - deps.target is "minor"`. */
+    protected explain(rule: string, about: NodeDependencyUpdater.Decision, range: string): string;
     /** Moves `d` down to `index` (`-1` keeps what is declared), remembering why it left its newest. */
     protected stepTo(d: NodeDependencyUpdater.Decision, index: number, rule: string): void;
     /** The version `d` resolves to: the one it moves to, or else the newest release its declarations
      *  already allow, which is what an install picks. */
     protected effective(d: NodeDependencyUpdater.Decision): string | undefined;
+    /** The newest release `d`'s declarations already allow - what an install picks if `d` does not
+     *  move. */
+    protected resolvedDeclared(d: NodeDependencyUpdater.Decision): string | undefined;
     /** What `d` declares in `field` once it has moved. */
     protected rangeFor(d: NodeDependencyUpdater.Decision, field: string): string;
     /** The in-repo packages `pkg` declares a dependency on. */

package/builtins/platforms/node/node-dependency-updater.js

@@ -357,15 +357,36 @@ export class NodeDependencyUpdater {
             return false;
         if (about.index >= 0) {
             const fits = about.candidates.findIndex((v, i) => i > about.index && semver.satisfies(v, range));
-            this.stepTo(about, fits, rule);
-            return true;
+            if (fits >= 0) {
+                this.stepTo(about, fits, rule);
+                return true;
+            }
+            const declared = this.resolvedDeclared(about);
+            if (declared && semver.satisfies(declared, range, { includePrerelease: true })) {
+                this.stepTo(about, -1, rule);
+                return true;
+            }
+            /* Nothing `about` may move to keeps the rule - so stepping it down gains nothing, and since a
+             * decision only ever steps down it would never come back up once the side stating the rule
+             * had given way. Measured on `abisena/syncbridge-iomt`: `@syncbridge/builtins@0.14.13` needs
+             * `@syncbridge/common ^0.14.0`, which `deps.target: minor` leaves out (a 0.x minor is a
+             * major), and `common`'s own `0.13.9` was dropped for it - then `builtins` stepped back too,
+             * and both read "not updated" with a reason pointing at a move that never happened. */
         }
         if (stating && stating.index >= 0) {
-            this.stepTo(stating, stating.index + 1 < stating.candidates.length ? stating.index + 1 : -1, rule);
+            this.stepTo(stating, stating.index + 1 < stating.candidates.length ? stating.index + 1 : -1, this.explain(rule, about, range));
             return true;
         }
         return false;
     }
+    /** `rule`, plus why `about` cannot meet it when the version that would is one its own settings
+     *  leave out - `0.14.0: major - deps.target is "minor"`. */
+    explain(rule, about, range) {
+        const newest = about.available;
+        if (!newest || !about.skipReason || !semver.satisfies(newest, range, { includePrerelease: true }))
+            return rule;
+        return `${rule} (${about.name}@${newest}: ${about.skipReason})`;
+    }
     /** Moves `d` down to `index` (`-1` keeps what is declared), remembering why it left its newest. */
     stepTo(d, index, rule) {
         if (d.index === 0 && !d.reason)
@@ -375,8 +396,11 @@ export class NodeDependencyUpdater {
     /** The version `d` resolves to: the one it moves to, or else the newest release its declarations
      *  already allow, which is what an install picks. */
     effective(d) {
-        if (d.index >= 0)
-            return d.candidates[d.index];
+        return d.index >= 0 ? d.candidates[d.index] : this.resolvedDeclared(d);
+    }
+    /** The newest release `d`'s declarations already allow - what an install picks if `d` does not
+     *  move. */
+    resolvedDeclared(d) {
         if (!d.releases?.size)
             return undefined;
         const ranges = [...d.fields.values()].filter(r => semver.validRange(r));

package/builtins/platforms/node/services/publish.service.d.ts

@@ -13,6 +13,8 @@ export declare namespace PublishService {
         /** A package with uncommitted local changes is excluded (status `'skip'`) instead of aborting
          *  the whole plan (status `'error'`) - same as `version`'s own option. Default false. */
         ignoreDirty?: boolean;
+        /** Which packages are the npm target's (`shipsTo`) - every one the filters keep when omitted. */
+        shipsHere?: (pkg: Package) => boolean;
         /** Registry to check against (and, in `applyPlan`, publish to) - `.npmrc`'s own configured
          *  registry is used when omitted. */
         registry?: string;
@@ -138,6 +140,24 @@ export declare namespace PublishService {
      *  place of `npm`. */
     function registryLabel(pkg: Package): string | undefined;
     function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
+    interface WaitOptions {
+        /** As in `Options` - the registry each package is asked on is resolved the same way. */
+        registry?: string;
+        userconfig?: string;
+        /** How long to keep asking, in milliseconds. Default five minutes. */
+        timeoutMs?: number;
+        /** How long between rounds, in milliseconds. Default five seconds. */
+        intervalMs?: number;
+    }
+    /**
+     * Asks each package's registry, every `intervalMs`, whether it serves the version just published,
+     * until all of them do or `timeoutMs` passes. Returns the entries still missing - none when every
+     * version showed up.
+     *
+     * A staged entry is not waited for: it stays in npm's queue until a maintainer approves it, which
+     * no wait in a release job can outlast.
+     */
+    function waitUntilAvailable(entries: Entry[], options?: WaitOptions, deps?: Deps): Promise<Entry[]>;
     /**
      * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
      * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not

package/builtins/platforms/node/services/publish.service.js

@@ -195,7 +195,7 @@ export var PublishService;
     PublishService.registryLabel = registryLabel;
     async function getPlan(repository, options = {}, deps = {}) {
         const git = new GitHelper({ cwd: repository.dirname });
-        const packages = filterPackages(repository.getPackages({ toposort: true }), options);
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(pkg => options.shipsHere?.(pkg) ?? true);
         const dirtyFiles = await git.listDirtyFiles({ absolute: true });
         const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
         /** Per package, not per run: `resolveRegistry` reads the package's own `publishConfig.registry`
@@ -290,6 +290,40 @@ export var PublishService;
         return packages.map(pkg => entries.get(pkg.name));
     }
     PublishService.getPlan = getPlan;
+    /**
+     * Asks each package's registry, every `intervalMs`, whether it serves the version just published,
+     * until all of them do or `timeoutMs` passes. Returns the entries still missing - none when every
+     * version showed up.
+     *
+     * A staged entry is not waited for: it stays in npm's queue until a maintainer approves it, which
+     * no wait in a release job can outlast.
+     */
+    /* `--prefer-online`, or npm answers from the copy of the package document it cached before the
+     * publish. One round asks about every pending package at once. */
+    async function waitUntilAvailable(entries, options = {}, deps = {}) {
+        const pending = new Set(entries.filter(e => e.status === 'publish' && !e.staged));
+        const deadline = Date.now() + (options.timeoutMs ?? 300_000);
+        const interval = options.intervalMs ?? 5_000;
+        const view = (pkg) => deps.npmViewPackage
+            ? deps.npmViewPackage(pkg.name, pkg.dirname)
+            : npmViewPackage(pkg.name, pkg.dirname, {
+                userconfig: options.userconfig,
+                registry: resolveRegistry(pkg, options.registry),
+                preferOnline: true,
+            });
+        while (pending.size) {
+            await Promise.all([...pending].map(async (entry) => {
+                if ((await view(entry.package))?.versions.includes(entry.version))
+                    pending.delete(entry);
+            }));
+            const left = deadline - Date.now();
+            if (!pending.size || left <= 0)
+                break;
+            await new Promise(resolve => setTimeout(resolve, Math.min(interval, left)));
+        }
+        return [...pending];
+    }
+    PublishService.waitUntilAvailable = waitUntilAvailable;
     /**
      * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
      * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not

package/builtins/publish-targets/npm/npm-publish-target.d.ts

@@ -1,5 +1,5 @@
 import type { Package } from '../../../core/classes/package.js';
-import type { PublishTarget } from '../../../core/interfaces/publish-target.js';
+import { type PublishTarget } from '../../../core/interfaces/publish-target.js';
 import { PublishService } from '../../platforms/node/services/publish.service.js';
 /** The name this target answers to in `publish.target` and `--target`. */
 export declare const NPM_TARGET = "npm";
@@ -79,5 +79,6 @@ export declare class NpmPublishTarget implements PublishTarget {
     applyPlan(ctx: PublishTarget.Context, plan: PublishTarget.Entry[]): Promise<PublishService.Entry[]>;
     /** The shared filters plus the two flags both halves need - read here rather than in the
      *  service, which keeps taking a plain options object and stays callable without a CLI. */
+    waitUntilAvailable(ctx: PublishTarget.Context, published: PublishTarget.Entry[]): Promise<PublishService.Entry[]>;
     protected planOptions(ctx: PublishTarget.Context): PublishService.Options;
 }

package/builtins/publish-targets/npm/npm-publish-target.js

@@ -1,3 +1,4 @@
+import { shipsTo } from '../../../core/interfaces/publish-target.js';
 import { CiService } from '../../platforms/node/services/ci.service.js';
 import { PublishService } from '../../platforms/node/services/publish.service.js';
 /** The name this target answers to in `publish.target` and `--target`. */
@@ -31,7 +32,7 @@ export class NpmPublishTarget {
         packageManager: {
             target: 'cli',
             cliName: 'package-manager',
-            describe: 'Package manager to publish with (default: npm, or .rmanrc "packageManager")',
+            describe: 'Package manager to publish with (default: .rmanrc "packageManager.node", else npm)',
             choices: CiService.PACKAGE_MANAGERS,
         },
         access: {
@@ -96,9 +97,18 @@ export class NpmPublishTarget {
     }
     /** The shared filters plus the two flags both halves need - read here rather than in the
      *  service, which keeps taking a plain options object and stays callable without a CLI. */
+    waitUntilAvailable(ctx, published) {
+        return PublishService.waitUntilAvailable(published, {
+            registry: ctx.args.registry,
+            userconfig: ctx.args.userconfig,
+        });
+    }
     planOptions(ctx) {
         return {
             ...ctx.options,
+            /** `publish` drops the rest from the plan anyway; asked here too so a docker-only package
+             *  costs no `npm view`. */
+            shipsHere: pkg => shipsTo(pkg, this),
             registry: ctx.args.registry,
             userconfig: ctx.args.userconfig,
             /** Read at *plan* time too, not only where the publish command is built: the plan is what

package/builtins/publish-targets/npm/npm-view.d.ts

@@ -31,6 +31,7 @@ export interface NpmPackageView {
 export declare function npmViewPackage(name: string, cwd: string, options?: {
     registry?: string;
     userconfig?: string;
+    preferOnline?: boolean;
 }): Promise<NpmPackageView | undefined>;
 /**
  * `npm view <name> version` - the **`latest` dist-tag's** version, or `undefined` for anything that

package/builtins/publish-targets/npm/npm-view.js

@@ -27,6 +27,10 @@ export async function npmViewPackage(name, cwd, options = {}) {
         argv.push('--registry', options.registry);
     if (options.userconfig)
         argv.push('--userconfig', options.userconfig);
+    /** Past npm's local cache - a caller polling for a version it just published would otherwise be
+     *  answered from the copy fetched before the publish. */
+    if (options.preferOnline)
+        argv.push('--prefer-online');
     try {
         const { stdout } = await execFileAsync('npm', argv, { cwd });
         const text = stdout.trim();

package/cli.js

@@ -19,6 +19,7 @@ import { assertNoBuiltinShadowing, defaultCommandGlobs, describeCommandSource, l
 import { checkCustomCommand } from './core/plugin-loader.js';
 import { commandRegistry } from './interfaces/rman-config.interface.js';
 import { colorYaml } from './utils/color-yaml.js';
+import { askEnterOrEsc } from './utils/key-prompt.js';
 import { filterPackages, readFromRootOption, readPackageFilterOptions } from './utils/package-filter.js';
 import { printableConfig, withoutContributions } from './utils/printable-config.js';
 import { runBin } from './utils/run-bin.js';
@@ -41,7 +42,14 @@ export async function runCli(options) {
         /** One application per run, made here so `--log-level` reaches its logger, and handed to
          *  `Repository.create` rather than found through a global. */
         const app = options?.app ?? new RmanApplication();
-        const repository = await Repository.create(options?.cwd, { app, presets: options?.presets });
+        const missingPresets = [];
+        const repository = await Repository.create(options?.cwd, {
+            app,
+            presets: options?.presets,
+            onMissingExtends: (target, from) => missingPresets.push({ target, from }),
+        });
+        if (missingPresets.length)
+            await confirmMissingPresets(missingPresets, _argv);
         const program = yargs(_argv)
             .scriptName('rman')
             .version(version)
@@ -68,6 +76,14 @@ export async function runCli(options) {
             describe: 'Write the log as JSON Lines - one event per line on stdout, and no panel, spinner or prose. ' +
                 'A command that prints a result (list, version, publish, ...) prints that result as JSON',
             type: 'boolean',
+        })
+            /** **Global**, like `--json`: a command that asks for confirmation declares its own `--yes`
+             *  with the same meaning, and this one also answers the question asked before any command
+             *  runs - whether to go on without a preset that cannot be found. */
+            .option('yes', {
+            alias: 'y',
+            describe: 'Answer yes to every question - including going on without an "extends" preset that cannot be found',
+            type: 'boolean',
         })
             .option('log-file', {
             describe: 'Also write the log to this file - JSON Lines under --json, plain text lines otherwise. ' +
@@ -639,6 +655,50 @@ function commandContext(repository, app, args) {
         parallel: (tasks, options) => run.parallel(tasks, options ?? {}),
     };
 }
+/**
+ * Warns about the `extends` presets that could not be found - their settings are left out - and
+ * asks whether to go on: **Enter** continues, **Esc** cancels. `--yes` goes on without asking; with
+ * no terminal to ask on, it is an error that says to pass `--yes`.
+ *
+ * `--help` is never held up: it is what someone reaches for in exactly this situation.
+ */
+/* **It was an error outright**, and the case that made that wrong is a repository whose
+ * `node_modules` is not installed yet: its shared preset is nowhere to be found, so `rman ci` - the
+ * command that would install it - could not start. Without a terminal there is nobody to ask, and a
+ * release in CI quietly built without its preset is the worse outcome, so the error stays there
+ * unless `--yes` says otherwise. */
+async function confirmMissingPresets(missing, argv) {
+    if (!argv.length || argv.some(arg => arg === '-h' || arg === '--help'))
+        return;
+    const byTarget = new Map();
+    for (const { target, from } of missing) {
+        const where = path.relative(process.cwd(), from) || from;
+        byTarget.set(target, [...new Set([...(byTarget.get(target) ?? []), where])]);
+    }
+    const width = Math.max(...[...byTarget.keys()].map(t => t.length));
+    console.error(colors.yellow('These presets could not be found, so their settings are left out:'));
+    for (const [target, files] of byTarget) {
+        console.error(`  ${colors.cyan(target.padEnd(width))}  ${colors.gray(`extends in ${files.join(', ')}`)}`);
+    }
+    console.error(colors.gray('Are they installed? "rman ci" installs the repository\'s dependencies.'));
+    if (argv.some(arg => arg === '--yes' || arg === '-y')) {
+        console.error(colors.gray('Continuing without them (--yes).'));
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        throw logged('No terminal to ask on - pass --yes to continue without them.');
+    }
+    if (!(await askEnterOrEsc(colors.yellow('Press Enter to continue without them, Esc to cancel. ')))) {
+        throw logged('Cancelled.');
+    }
+}
+/** The `logged` convention: printed here, so the caller'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;
+}
 /**
  * `--log-level` read straight off argv, for a message printed **before** yargs parses anything.
  *

package/commands/deps.command.js

@@ -190,52 +190,89 @@ function jsonPlan(entries) {
     }));
 }
 /**
- * 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.
+ * One table per package with something to say, under a header: what each dependency would move to
+ * and how far, and for one that stays, the newest release and why it is not taken.
  */
-/* **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. */
+/* **One row per dependency, the change a column.** It was a list per size (`patch`, `minor`) and a
+ * second list headed "not updated" - wrong for a command that, without `-u`, updates nothing, and a
+ * dependency that moved part of the way appeared in both. The `Change` column says what a row is:
+ * the size of the move, or `held` (another dependency's rule refuses it), `skipped` (the package's
+ * own settings leave the newer version out) or `error`. Moves first, smallest first, then the rest. */
 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));
-    /** Said first when nothing moves, so a run whose only lines are majors left behind does not read
+    const shown = entries.filter(e => e.status !== 'up-to-date');
+    /** Said first when nothing moves, so a run whose only rows are majors left behind does not read
      *  as a list of things to do. */
     if (!updated.length) {
         console.log(colors.green('All dependencies are up to date') +
-            (behind.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
-        if (!behind.length)
+            (shown.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
+        if (!shown.length)
             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}`;
+    const header = ['Dependency', 'Current', 'Upgrade', 'Latest', 'Change'];
+    const cells = (e) => [
+        e.name,
+        e.current,
+        e.status === 'update' ? (e.target ?? '') : '-',
+        e.status === 'error' ? '-' : (e.available ?? e.latest ?? ''),
+        changeOf(e),
+    ];
+    const widths = header.map((h, i) => Math.max(h.length, ...shown.map(e => cells(e)[i].length)));
+    /** Padded to the column, except a last value nothing follows - trailing spaces inside a colour
+     *  code are past the reach of `trimEnd`. */
+    const line = (values, paint = text => text) => '  ' + values.map((v, i) => paint(i === values.length - 1 ? v : v.padEnd(widths[i]), i)).join('  ');
     for (const pkg of [...new Set(shown.map(e => e.package))]) {
+        const sizes = pkg.versionScheme.bumpNames;
+        const rank = (e) => e.status === 'update' ? sizes.indexOf(e.bump) : sizes.length + ['held', 'skipped', 'error'].indexOf(e.status);
+        const rows = shown.filter(e => e.package === pkg).sort((x, y) => rank(x) - rank(y));
         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)
+        console.log(colors.gray(line([...header, 'Note']).trimEnd()));
+        for (const e of rows) {
+            const paint = e.status === 'update' ? sizeColor(e.bump, sizes) : changeColor(e.status);
+            const values = cells(e);
+            if (e.reason)
+                values[4] = values[4].padEnd(widths[4]);
+            const text = line(values, (v, column) => (column === 2 || column === 4 ? paint(v) : v));
+            if (!e.reason) {
+                console.log(text);
                 continue;
-            const paint = sizeColor(size, sizes);
-            console.log(`  ${paint(size ?? 'other')}`);
-            for (const e of group)
-                console.log(row(e, `→  ${paint(e.target ?? '')}`));
+            }
+            const indent = 2 + widths.reduce((sum, w) => sum + w + 2, 0);
+            const note = wrapNote(e.reason, process.stdout.isTTY ? process.stdout.columns - indent : 0);
+            console.log(`${text}  ${note.map(l => colors.gray(l)).join('\n' + ' '.repeat(indent))}`);
         }
-        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 ?? '')}`));
+    }
+}
+/**
+ * A note cut into lines of at most `width` characters, at spaces, so a long one continues under its
+ * own column instead of wrapping to the terminal's left edge. One line when `width` is too narrow to
+ * be worth it, or 0 - output that is not a terminal has no edge to wrap at.
+ */
+function wrapNote(note, width) {
+    if (width < 20 || note.length <= width)
+        return [note];
+    const lines = [];
+    let current = '';
+    for (const word of note.split(' ')) {
+        if (current && current.length + 1 + word.length > width) {
+            lines.push(current);
+            current = word;
         }
+        else
+            current = current ? `${current} ${word}` : word;
     }
+    if (current)
+        lines.push(current);
+    return lines;
+}
+/** What the `Change` column says: the size of the move, or why there is none. */
+function changeOf(e) {
+    return e.status === 'update' ? (e.bump ?? 'other') : e.status;
+}
+/** `held` and `skipped` in yellow, an error in red - a row with no move to colour by size. */
+function changeColor(status) {
+    return status === 'error' ? colors.red : colors.yellow;
 }
 /** 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. */

package/commands/publish.command.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import readline from 'node:readline/promises';
 import colors from 'ansi-colors';
-import { unknownTargets } from '../core/interfaces/publish-target.js';
+import { shipsTo, unknownTargets } from '../core/interfaces/publish-target.js';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../utils/branch-guard.js';
 import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
@@ -121,8 +121,14 @@ const publishCommand = registerCommand(app => {
             };
             assertDeclaredTargetsExist(app, repository.getPackages());
             const plans = new Map();
-            for (const target of selected)
-                plans.set(target, await target.getPlan(ctx));
+            /** A target's plan keeps only the packages that ship to it, whatever the target itself
+             *  filtered - see `shipsTo`. Asked here, once for every target, because leaving it to each
+             *  one let them disagree: the npm target never asked, so a package declaring
+             *  `publish.target: ['docker']` was planned for npm too while `rman list` and the docker
+             *  target called it docker-only (panates/rman#40). */
+            for (const target of selected) {
+                plans.set(target, (await target.getPlan(ctx)).filter(entry => shipsTo(entry.package, target)));
+            }
             if (args.json) {
                 console.log(JSON.stringify(jsonPlan(plans), undefined, 2));
             }
@@ -165,9 +171,19 @@ const publishCommand = registerCommand(app => {
             if (!proceed)
                 return;
             const outcomes = [];
+            const publishedBy = new Map();
+            let waited = false;
             for (const [target, plan] of plans) {
+                /** Once, before the first target built from what the others published - see
+                 *  `PublishTarget.waitUntilAvailable`. */
+                if (target.publishesLast && !waited && plan.some(e => e.status === 'publish')) {
+                    waited = true;
+                    await waitForPublished(ctx, publishedBy);
+                }
                 const applied = await target.applyPlan(ctx, plan);
-                outcomes.push(...printApplied(applied, plan, target.name));
+                const done = printApplied(applied, plan, target.name);
+                outcomes.push(...done);
+                publishedBy.set(target, done.filter(o => o.entry.status === 'publish').map(o => o.entry));
             }
             if (!args.json)
                 printRecap(outcomes);
@@ -274,6 +290,28 @@ function printPlan(entries, label) {
         }
     }
 }
+/**
+ * Waits for every target that can say so to serve what it just published, so a target building from
+ * those packages finds them. On stderr, as progress rather than part of the answer; a version still
+ * missing at the end is reported and the build goes ahead - it may have arrived since, and if not,
+ * the build's own error now says which version it could not find.
+ */
+async function waitForPublished(ctx, publishedBy) {
+    for (const [target, published] of publishedBy) {
+        if (!target.waitUntilAvailable || !published.length)
+            continue;
+        const started = Date.now();
+        console.error(colors.gray(`waiting for ${published.length} package(s) to be served by [${target.name}]...`));
+        const missing = await target.waitUntilAvailable(ctx, published);
+        const took = ((Date.now() - started) / 1000).toFixed(1);
+        if (!missing.length) {
+            console.error(colors.gray(`[${target.name}] serves all ${published.length} (${took}s)`));
+            continue;
+        }
+        console.error(colors.yellow(`[${target.name}] still does not serve ${missing.map(e => `${e.package.name}@${e.version}`).join(', ')} ` +
+            `after ${took}s - building anyway`));
+    }
+}
 /**
  * What one target actually did, printed as it is known. Returns the outcome of every package the
  * *plan* said to publish.

package/constants.js

@@ -1 +1 @@
-export const version = '2.18.2';
+export const version = '2.19.1';

package/core/classes/repository.d.ts

@@ -236,6 +236,9 @@ export declare class Repository extends Package {
         deep?: number;
         app?: RmanApplication;
         presets?: readonly string[];
+        /** See `ConfigReader`'s constructor: an `extends` package that cannot be found is reported
+         *  here and left out, rather than failing the read. */
+        onMissingExtends?: (target: string, from: string) => void;
     }): Promise<Repository>;
     /**
      * Takes the workspace's packages as this repository's own - the back-references a `Package` needs

package/core/classes/repository.js

@@ -7,6 +7,7 @@ import { RmanApplication } from '../application.js';
 import { ConfigFileScope } from '../config/config-file-scope.js';
 import { ConfigInterpolator } from '../config/config-interpolator.js';
 import { DEFERRED_PATHS } from '../config/config-paths.js';
+import { ConfigReader } from '../config/config-reader.js';
 import { Manifest } from '../interfaces/manifest.js';
 import { Package } from './package.js';
 import { Workspace } from './workspace.js';
@@ -596,6 +597,7 @@ export class Repository extends Package {
             deep: options?.deep,
             platforms: [...app.platforms],
             presets: options?.presets,
+            reader: options?.onMissingExtends ? new ConfigReader({ onMissingExtends: options.onMissingExtends }) : undefined,
         });
         /** What the configs named, onto the application the commands read from. */
         for (const platform of workspace.platforms)

package/core/config/config-reader.d.ts

@@ -8,6 +8,18 @@ export declare class ConfigReader {
      * @protected
      */
     protected readonly configFiles: readonly string[];
+    /** Told about an `extends` package that cannot be found, which is then left out - see the
+     *  constructor. */
+    protected readonly onMissingExtends?: (target: string, from: string) => void;
+    /**
+     * `onMissingExtends`, when given, turns an `extends` naming a **package** that cannot be found -
+     * `@scope/preset` or `rman:<name>` - into a call to it, and the config is read without that base.
+     * Without it such a target is an error, as it always was. A relative path that does not exist is
+     * an error either way: it is the repository's own file, and missing it is a typo.
+     */
+    constructor(options?: {
+        onMissingExtends?: (target: string, from: string) => void;
+    });
     /**
      * Whether a config key names **packages** rather than a setting: `"[*]"`, `"[/]"`, `"[pkg-a]"`.
      */

package/core/config/config-reader.js

@@ -39,6 +39,21 @@ export class ConfigReader {
         '.rmanrc.mjs',
         '.rmanrc.js',
     ];
+    /** Told about an `extends` package that cannot be found, which is then left out - see the
+     *  constructor. */
+    onMissingExtends;
+    /**
+     * `onMissingExtends`, when given, turns an `extends` naming a **package** that cannot be found -
+     * `@scope/preset` or `rman:<name>` - into a call to it, and the config is read without that base.
+     * Without it such a target is an error, as it always was. A relative path that does not exist is
+     * an error either way: it is the repository's own file, and missing it is a typo.
+     */
+    /* For the CLI, which asks before going on: a repository whose `node_modules` is not installed yet
+     * has its shared preset nowhere to be found, and refusing to start left `rman ci` - the command
+     * that installs it - unable to run. A library caller keeps the error unless it asks otherwise. */
+    constructor(options) {
+        this.onMissingExtends = options?.onMissingExtends;
+    }
     /**
      * Whether a config key names **packages** rather than a setting: `"[*]"`, `"[/]"`, `"[pkg-a]"`.
      */
@@ -460,7 +475,17 @@ export class ConfigReader {
         }
         const base = {};
         for (const target of targets) {
-            const file = this._resolveExtendTarget(target, from, EXTENDS_KEY);
+            let file;
+            try {
+                file = this._resolveExtendTarget(target, from, EXTENDS_KEY);
+            }
+            catch (e) {
+                const isPath = target.startsWith('.') || path.isAbsolute(target);
+                if (!this.onMissingExtends || isPath)
+                    throw e;
+                this.onMissingExtends(target, from);
+                continue;
+            }
             if (seen.includes(file)) {
                 throw new Error(`"extends" forms a cycle: ${[...seen, file].map(f => path.basename(f)).join(' -> ')}`);
             }

package/core/interfaces/publish-target.d.ts

@@ -79,6 +79,14 @@ export interface PublishTarget {
      * registry's host, `npm.pkg.github.com` for GitHub Packages. `undefined` shows `name`.
      */
     labelFor?(pkg: Package): string | undefined;
+    /**
+     * Waits until what `applyPlan` just published is served by this target's registry, and returns
+     * the entries that still are not when it gives up - none when everything showed up.
+     *
+     * Asked by `publish` before a `publishesLast` target runs, so an image built from these packages
+     * finds them. Absent, nothing waits for this target.
+     */
+    waitUntilAvailable?(ctx: PublishTarget.Context, published: PublishTarget.Entry[]): Promise<PublishTarget.Entry[]>;
     /** What this target *would* do - never publishes. Called even under `--dry-run`, which is the
      *  whole point of the split. */
     getPlan(ctx: PublishTarget.Context): Promise<PublishTarget.Entry[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.18.2",
+  "version": "2.19.1",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/utils/key-prompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Writes `question` to stderr and waits for one key: **Enter** answers `true`, **Esc** or
+ * **Ctrl+C** answers `false`. Any other key is ignored.
+ *
+ * Only for a terminal - the caller checks `process.stdin.isTTY` first, since there is no key to
+ * wait for in a pipe.
+ */
+export declare function askEnterOrEsc(question: string, 
+/** Where the key comes from - the terminal, unless a caller (a spec) brings its own. */
+stdin?: Pick<NodeJS.ReadStream, 'isRaw' | 'setRawMode' | 'resume' | 'pause' | 'on' | 'off'>): Promise<boolean>;

package/utils/key-prompt.js

@@ -0,0 +1,35 @@
+/**
+ * Writes `question` to stderr and waits for one key: **Enter** answers `true`, **Esc** or
+ * **Ctrl+C** answers `false`. Any other key is ignored.
+ *
+ * Only for a terminal - the caller checks `process.stdin.isTTY` first, since there is no key to
+ * wait for in a pipe.
+ */
+/* One key rather than a typed answer, because the question is a gate in front of the whole run and
+ * the two answers are "go on" and "stop". An escape sequence (an arrow key arrives as `\x1b[A`) is
+ * not Esc: only a lone `\x1b` cancels. */
+export function askEnterOrEsc(question, 
+/** Where the key comes from - the terminal, unless a caller (a spec) brings its own. */
+stdin = process.stdin) {
+    process.stderr.write(question);
+    return new Promise(resolve => {
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        const finish = (answer) => {
+            stdin.off('data', onKey);
+            stdin.setRawMode(wasRaw);
+            stdin.pause();
+            process.stderr.write('\n');
+            resolve(answer);
+        };
+        const onKey = (data) => {
+            const key = data.toString();
+            if (key === '\r' || key === '\n')
+                finish(true);
+            else if (key === '\x1b' || key === '\x03')
+                finish(false);
+        };
+        stdin.on('data', onKey);
+    });
+}