rman 2.16.0 → 2.18.0

package/README.md

@@ -169,7 +169,7 @@ orders by dependencies instead, and `--json` keeps the inventory's own order.
 
 Prints local environment (OS/CPU/memory, Node, git) and repository information. A platform adds its
 own ecosystem's part - the `node` built-in reports whichever package manager
-`.rmanrc "packageManager"` names (`npm` by default), plus the installed `rman` and `typescript`.
+`.rmanrc "packageManager.node"` names (`npm` by default), plus the installed `rman` and `typescript`.
 
 ```bash
 rman info
@@ -430,7 +430,8 @@ such as `"[*]"` the packages below.
 
 ```yaml
 # .rmanrc.yml, at the repository root
-packageManager: pnpm
+packageManager:
+  node: pnpm
 logLevel: info
 allowBranch: [main, release/*]
 

package/builtins/platforms/node/augmentation/rmanrc.augmentation.d.ts

@@ -1,5 +1,5 @@
 import type { cleanCommand, CleanExtraKeys } from '../commands/clean.command.js';
-import type { NodeConfigKeys, RmanNodeConfig } from '../node-config.interface.js';
+import type { NodeConfigKeys, NodePackageManagers, RmanNodeConfig } from '../node-config.interface.js';
 import type { CiService } from '../services/ci.service.js';
 /**
  * **Every type this plugin adds to rman, in one `declare module` block.**
@@ -25,6 +25,9 @@ declare module '../../../../interfaces/rman-config.interface.js' {
      */
     interface RmanConfigKeys extends NodeConfigKeys {
     }
+    /** Node's entry in `.rmanrc "packageManager"` - `{ node: 'pnpm' }`. */
+    interface PackageManagers extends NodePackageManagers {
+    }
     /**
      * **`clean.*`, contributed by the command that reads it**, the way every built-in contributes its
      * own key - `skip` derived from the command's `config` block, `include`/`exclude` hand-written in
@@ -74,7 +77,7 @@ declare module '../../../../services/system-info.js' {
             /**
              * Report this package manager's version under `Binaries`, plus the `npmPackages` sections.
              *
-             * Defaults to `.rmanrc "packageManager"` (read off `Options.repository`), then to `npm` -
+             * Defaults to `.rmanrc "packageManager.node"` (read off `Options.repository`), then to `npm` -
              * this package being installed is itself the statement that the repository is a Node one.
              */
             packageManager?: PackageManager;

package/builtins/platforms/node/augmentation/system-info.augmentation.js

@@ -1,4 +1,5 @@
 import { SystemInfo as OrgSystemInfo } from '../../../../services/system-info.js';
+import { CiService } from '../services/ci.service.js';
 /**
  * Adds the npm half of `SystemInfo` to rman's own types.
  *
@@ -41,7 +42,12 @@ export function augmentSystemInfo() {
         /** An explicit argument first, then the repository's own config, then npm. The config step is
          *  why the core declares `Options.repository`: `rman info` passes only that, so without it a
          *  pnpm repository would silently be reported as an npm one. */
-        const packageManager = options?.packageManager ?? asPackageManager(options?.repository?.config?.packageManager) ?? 'npm';
+        /** The old bare `packageManager: pnpm` is refused here as `ci` and `publish` refuse it - read
+         *  as a map it has no `node` entry, and `info` would report npm for a pnpm repository. */
+        const configured = options?.repository?.config?.packageManager;
+        if (typeof configured === 'string')
+            CiService.resolvePackageManager(options.repository);
+        const packageManager = options?.packageManager ?? asPackageManager(configured?.node) ?? 'npm';
         return base({
             ...options,
             envinfo: {

package/builtins/platforms/node/node-config.interface.d.ts

@@ -1,31 +1,18 @@
 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.
- *
- * **One key, and it is here because no single command owns it**: `packageManager` is read by `ci`
- * *and* by the `npm` publish target, so neither can contribute it. Everything else this package
- * adds to `.rmanrc` is declared by whoever reads it - `clean.*` by `clean.command.ts` (through
- * `CommandContribution`), `publish.npm.*` by the target, below.
- *
- * **Two surfaces, and they are not alternatives:**
- *
- * - the `declare module 'rman'` block in [`../augmentation/rman.augmentation.ts`] merges this into
- *   `RmanConfigKeys`, so `repository.config.packageManager` stays typed wherever it is read with no
- *   cast. It lives there because one such block per package is the limit;
- * - `RmanNodeConfig` is the name a *config author* annotates with, which is what makes the import
- *   carrying that augmentation explicit instead of a side effect someone has to remember.
+ * The `.rmanrc` keys that only mean something because the repository is a Node one, merged into
+ * `RmanConfigKeys` by `rmanrc.augmentation.ts`. Everything else this built-in adds is declared by
+ * whoever reads it - `clean.*` by `clean.command.ts`, `publish.npm.*` by the target, below.
  */
 export interface NodeConfigKeys {
-    /**
-     * Which package manager `ci`/`publish` shell out to, and whose version `info` reports under
-     * `Binaries`. Root level only. Default `npm`.
-     *
-     * It used to be a core key, on the grounds that `info` read it - and that stopped being true the
-     * moment `SystemInfo`'s npm half moved here: measured, **nothing in rman's core reads it at
-     * all**, only the declaration was left behind. The value set was npm's tooling the whole time.
-     */
-    packageManager?: CiService.PackageManager;
+}
+/**
+ * Node's entry in `.rmanrc "packageManager"`: which package manager `ci` installs with, `publish`
+ * publishes with and `info` reports - `packageManager: { node: pnpm }`. Default `npm`.
+ */
+export interface NodePackageManagers {
+    node?: CiService.PackageManager;
 }
 export declare namespace RmanNodeConfig {
     /**

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

@@ -1,4 +1,5 @@
 import type { LogLevel } from '../../../../core/classes/logger.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';
 export declare namespace CiService {
@@ -21,9 +22,11 @@ export declare namespace CiService {
          *  the root's `.rmanrc logLevel`, then 'info' - see `resolveRootLogLevel`. */
         logLevel?: LogLevel;
     }
-    /** `.rmanrc packageManager` (root only) picks the package manager used for the final install;
-     *  explicit CLI value wins over it. Defaults to 'npm'. */
-    function resolvePackageManager(repository: Repository, cliValue?: PackageManager): PackageManager;
+    /**
+     * The package manager `pkg` uses: `cliValue` when given, else its `.rmanrc "packageManager.node"`,
+     * else `npm`. Pass the repository for the one the repository installs with.
+     */
+    function resolvePackageManager(pkg: Package, cliValue?: PackageManager): PackageManager;
     /** Deletes `node_modules` and any known lockfile directly under `dirname`. Returns the names
      *  that actually existed (and were removed), so the caller can log only those. */
     function wipe(dirname: string): Promise<string[]>;

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

@@ -16,17 +16,28 @@ export var CiService;
      * act on. One list, one place it is written down.
      */
     CiService.PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];
-    /** `.rmanrc packageManager` (root only) picks the package manager used for the final install;
-     *  explicit CLI value wins over it. Defaults to 'npm'. */
-    function resolvePackageManager(repository, cliValue) {
+    /**
+     * The package manager `pkg` uses: `cliValue` when given, else its `.rmanrc "packageManager.node"`,
+     * else `npm`. Pass the repository for the one the repository installs with.
+     */
+    /* **The bare string is refused rather than read.** `packageManager: pnpm` was the old spelling,
+     * and rman validates no config keys, so read as an object it would simply have no `node` entry -
+     * a pnpm repository installing with npm, saying nothing. No repository of this organization
+     * wrote it, so a clear refusal costs nobody anything. */
+    function resolvePackageManager(pkg, cliValue) {
         if (cliValue)
             return cliValue;
-        const configured = repository.config?.packageManager;
-        if (configured === undefined)
+        const configured = pkg.config?.packageManager;
+        if (typeof configured === 'string') {
+            throw new Error(`.rmanrc "packageManager" takes one entry per technology - write packageManager: { node: ${configured} } ` +
+                `instead of packageManager: ${configured}.`);
+        }
+        const node = configured?.node;
+        if (node === undefined)
             return 'npm';
-        if (CiService.PACKAGE_MANAGERS.includes(configured))
-            return configured;
-        throw new Error(`Invalid "packageManager" in .rmanrc: "${configured}" (expected one of: ${CiService.PACKAGE_MANAGERS.join(', ')})`);
+        if (typeof node === 'string' && CiService.PACKAGE_MANAGERS.includes(node))
+            return node;
+        throw new Error(`Invalid "packageManager.node" in .rmanrc: "${String(node)}" (expected one of: ${CiService.PACKAGE_MANAGERS.join(', ')})`);
     }
     CiService.resolvePackageManager = resolvePackageManager;
     /** Deletes `node_modules` and any known lockfile directly under `dirname`. Returns the names

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

@@ -305,7 +305,6 @@ export var PublishService;
      * `consumerNeeds`).
      */
     async function applyPlan(repository, plan, options = {}) {
-        const packageManager = CiService.resolvePackageManager(repository, options.packageManager);
         const failed = new Set();
         const result = [];
         /** The tuple is explicit: `[p.name, p]` widens to `(string | Package)[]`, and whether `new Map`
@@ -331,7 +330,7 @@ export var PublishService;
                 /** The plan's own tag and staging decision, not recomputed ones: `getPlan` decided where
                  *  this package goes, the reader confirmed that, and `applyPlan` is here to carry it out.
                  *  `options.*` is the fallback only for a plan built by something other than `getPlan`. */
-                await exec(buildPublishCommand(packageManager, {
+                await exec(buildPublishCommand(CiService.resolvePackageManager(pkg, options.packageManager), {
                     ...options,
                     tag: entry.distTag ?? options.tag,
                     staged: entry.staged ?? options.staged,

package/builtins/platforms/node/utils/copy-assets.d.ts

@@ -0,0 +1,30 @@
+import type { RunBinOptions, RunBinResult } from '../../../../utils/run-bin.js';
+/**
+ * The files `copyAssets` copies when it is given no patterns: the data formats a package keeps
+ * beside its sources - translations, fixtures, schemas - that `tsc` does not emit.
+ */
+export declare const DEFAULT_ASSET_PATTERNS: readonly string[];
+export interface CopyAssetsOptions {
+    /** The tsconfig the build compiles with - its `rootDir` and `outDir` say where the files are and
+     *  where they go. */
+    tsconfig: string;
+    /** Globs over paths relative to `rootDir`. Default `DEFAULT_ASSET_PATTERNS`. */
+    patterns?: readonly string[];
+    /** Runs `tsc` - a function step's own `ctx.runBin`, which already resolves the repository's
+     *  installed copy. */
+    runBin: (bin: string, argv: string[], options?: RunBinOptions) => Promise<RunBinResult>;
+}
+/**
+ * Copies the files under a tsconfig's `rootDir` that match `patterns` into its `outDir`, keeping
+ * their place in the tree - `src/i18n/tr.json` lands at `build/i18n/tr.json`, where the compiled
+ * code that reads it expects to find it. Returns the files it wrote, absolute.
+ *
+ * `tsc` emits none of them: it compiles sources, and a `.json` reaches the output only when code
+ * imports it under `resolveJsonModule`. A file read at run time - a translation, an XML template, a
+ * fixture - is left behind, and the built package fails on a path that exists only in `src`.
+ *
+ * A tsconfig with no `outDir` compiles beside its sources, so there is nothing to copy and nothing
+ * is. `node_modules`, the output directory itself, `tsconfig*.json`, `package.json` and
+ * `package-lock.json` are never copied.
+ */
+export declare function copyAssets(options: CopyAssetsOptions): Promise<string[]>;

package/builtins/platforms/node/utils/copy-assets.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import glob from 'fast-glob';
+/**
+ * The files `copyAssets` copies when it is given no patterns: the data formats a package keeps
+ * beside its sources - translations, fixtures, schemas - that `tsc` does not emit.
+ */
+/* **A list, not "everything that is not TypeScript"** - the user's call, and the reason is what
+ * ships: a published package is what lands in a consumer's `node_modules`, and "every other file"
+ * puts a stray `.md`, a `.DS_Store` or a test's data file there with nothing saying so. A list
+ * leaves out what nobody named, and a repository that needs more names it. */
+export const DEFAULT_ASSET_PATTERNS = ['**/*.json', '**/*.xml', '**/*.yaml', '**/*.yml'];
+/**
+ * Copies the files under a tsconfig's `rootDir` that match `patterns` into its `outDir`, keeping
+ * their place in the tree - `src/i18n/tr.json` lands at `build/i18n/tr.json`, where the compiled
+ * code that reads it expects to find it. Returns the files it wrote, absolute.
+ *
+ * `tsc` emits none of them: it compiles sources, and a `.json` reaches the output only when code
+ * imports it under `resolveJsonModule`. A file read at run time - a translation, an XML template, a
+ * fixture - is left behind, and the built package fails on a path that exists only in `src`.
+ *
+ * A tsconfig with no `outDir` compiles beside its sources, so there is nothing to copy and nothing
+ * is. `node_modules`, the output directory itself, `tsconfig*.json`, `package.json` and
+ * `package-lock.json` are never copied.
+ */
+/* **`rootDir`/`outDir` are asked of `tsc --showConfig`, not read out of the file.** A package's
+ * tsconfig usually inherits both through `extends` - a relative path or a package such as
+ * `@panates/tsconfig` - and resolving that chain is `tsc`'s own logic: JSON with comments, a list
+ * of bases, package `exports`. `--showConfig` prints the resolved result with every path relative
+ * to the config it was given, in about 0.4s (measured on `panates/opra`'s `common`), which is small
+ * beside the compile it follows.
+ *
+ * **No `rootDir` means `tsc` computed one** - the common directory of its inputs - and `--showConfig`
+ * lists those inputs under `files`, so the same answer is taken from there. Declaration files are
+ * left out of it, as `tsc` leaves them out. */
+export async function copyAssets(options) {
+    const configDir = path.dirname(path.resolve(options.tsconfig));
+    /** **`onLine` swallows the lines**: a step's `runBin` hands every line to the step's log, and the
+     *  whole resolved configuration printed under the package is noise. `output` still collects them. */
+    let output;
+    try {
+        ({ output } = await options.runBin('tsc', ['--showConfig', '-p', options.tsconfig], {
+            stdio: 'pipe',
+            onLine: () => undefined,
+        }));
+    }
+    catch (e) {
+        throw new Error(`"tsc --showConfig -p ${options.tsconfig}" failed:\n${String(e?.output ?? e?.message).trim()}`, {
+            cause: e,
+        });
+    }
+    const config = parseShowConfig(output, options.tsconfig);
+    const outDir = config.compilerOptions?.outDir;
+    if (!outDir)
+        return [];
+    const out = path.resolve(configDir, outDir);
+    const root = config.compilerOptions?.rootDir
+        ? path.resolve(configDir, config.compilerOptions.rootDir)
+        : (commonDir((config.files ?? []).filter(f => !/\.d\.[cm]?ts$/.test(f)).map(f => path.resolve(configDir, f))) ??
+            configDir);
+    /** `package.json` and its lockfile because a `rootDir` of the package itself would otherwise send
+     *  them along - and the build directory's manifest is `publish`'s (or the preset's) to write. */
+    const ignore = ['**/node_modules/**', '**/tsconfig*.json', '**/package.json', '**/package-lock.json'];
+    const outInsideRoot = path.relative(root, out);
+    if (outInsideRoot && !outInsideRoot.startsWith('..') && !path.isAbsolute(outInsideRoot)) {
+        ignore.push(`${outInsideRoot.split(path.sep).join('/')}/**`);
+    }
+    const files = await glob([...(options.patterns ?? DEFAULT_ASSET_PATTERNS)], {
+        cwd: root,
+        ignore,
+        onlyFiles: true,
+        dot: false,
+    });
+    const written = [];
+    for (const rel of files.sort()) {
+        const target = path.join(out, rel);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.copyFileSync(path.join(root, rel), target);
+        written.push(target);
+    }
+    return written;
+}
+/** `tsc --showConfig`'s answer. It prints the JSON alone on success; anything else is a tsconfig
+ *  `tsc` could not read, which is reported with what it said. */
+function parseShowConfig(output, tsconfig) {
+    const start = output.indexOf('{');
+    try {
+        return JSON.parse(output.slice(start));
+    }
+    catch {
+        throw new Error(`"tsc --showConfig -p ${tsconfig}" did not print a configuration:\n${output.trim()}`);
+    }
+}
+/** The deepest directory holding every one of `files`, or `undefined` for none. */
+function commonDir(files) {
+    if (!files.length)
+        return undefined;
+    let common = path.dirname(files[0]);
+    for (const file of files.slice(1)) {
+        while (path.relative(common, file).startsWith('..'))
+            common = path.dirname(common);
+    }
+    return common;
+}

package/builtins/publish-targets/docker/docker-publish.service.js

@@ -183,7 +183,42 @@ async function buildAndPush(repository, entry) {
         args.push('--build-arg', `${name}="${expandEnvValue(value)}"`);
     }
     args.push('-f', `"${dockerfile}"`, '-t', `"${entry.image}:${entry.version}"`, '-t', `"${entry.image}:latest"`, '--push', '.');
-    await exec(`docker ${args.join(' ')}`, { cwd, app: repository.app, stdio: 'inherit' });
+    /** **Shown as it runs and kept**, so a failure can say why. It ran with `stdio: 'inherit'`, and the
+     *  one thing left to report was the exit code - measured on `panates/syncbridge`, the line that
+     *  explained the failure sat forty lines above the plan's recap and the recap said
+     *  `Command failed (1)`. On stderr, so a `--json` stdout stays one document. */
+    const lines = [];
+    const result = await exec(`docker ${args.join(' ')}`, {
+        cwd,
+        app: repository.app,
+        throwOnError: false,
+        onLine: line => {
+            lines.push(line);
+            process.stderr.write(line + '\n');
+        },
+    });
+    if (result.code)
+        throw new Error(`docker build exited with code ${result.code}${failureLines(lines)}`);
+}
+/**
+ * The lines of a failed build worth putting in a one-paragraph reason: those saying "error", with
+ * BuildKit's `#42 31.01 ` step prefix removed, each once - BuildKit prints a failing step's output
+ * twice, once as it runs and again in its summary - and without npm's pointer to its own log file.
+ * At most four, as an indented block under the first line.
+ */
+function failureLines(lines) {
+    const seen = new Set();
+    for (const raw of lines) {
+        const line = raw
+            .replace(/^#\d+\s+[\d.]+\s+/, '')
+            .replace(/^[\d.]+\s+/, '')
+            .trim();
+        if (!/\berror\b/i.test(line) || /complete log of this run/i.test(line))
+            continue;
+        seen.add(line);
+    }
+    const picked = [...seen].slice(0, 4);
+    return picked.length ? ':\n' + picked.map(l => `    ${l}`).join('\n') : '';
 }
 async function updateDescription(entry) {
     const pkg = entry.package;

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

@@ -14,6 +14,8 @@ import { DOCKER_TARGET } from './docker-publish.service.js';
 export const dockerPublishTarget = {
     name: DOCKER_TARGET,
     describe: 'Build and push a container image (docker buildx build --push)',
+    /** An image installs its dependencies from the registries the other targets push to. */
+    publishesLast: true,
     options: {
         dockerNamespace: {
             target: 'cli',

package/commands/publish.command.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import readline from 'node:readline/promises';
 import colors from 'ansi-colors';
 import { unknownTargets } from '../core/interfaces/publish-target.js';
@@ -109,7 +110,9 @@ const publishCommand = registerCommand(app => {
         handler: async (args) => {
             await assertAllowedBranch(repository, readBranchGuardOptions(args));
             const requested = args.target;
-            const selected = selectTargets(targets, requested);
+            /** A target built from what the others publish goes after them - see `publishesLast`. A
+             *  stable sort, so registration order still decides among the rest. */
+            const selected = selectTargets(targets, requested).sort((a, b) => Number(!!a.publishesLast) - Number(!!b.publishesLast));
             const ctx = {
                 app,
                 repository,
@@ -161,14 +164,21 @@ const publishCommand = registerCommand(app => {
             }
             if (!proceed)
                 return;
-            let failed = false;
+            const outcomes = [];
             for (const [target, plan] of plans) {
                 const applied = await target.applyPlan(ctx, plan);
-                if (printApplied(applied, plan, target.name))
-                    failed = true;
+                outcomes.push(...printApplied(applied, plan, target.name));
+            }
+            if (!args.json)
+                printRecap(outcomes);
+            writeStepSummary(outcomes);
+            const failed = outcomes.filter(o => o.entry.status === 'error');
+            /** **The names are in the line itself**, not only in the recap above it: in CI stdout and
+             *  stderr are separate pipes, and measured on `panates/syncbridge` this line landed in the
+             *  middle of the `published` lines rather than after them. */
+            if (failed.length) {
+                throw logged(`"publish" failed for ${failed.map(o => `[${o.target}] ${o.entry.package.name}`).join(', ')}`);
             }
-            if (failed)
-                throw logged('"publish" failed');
         },
     };
 });
@@ -265,25 +275,86 @@ function printPlan(entries, label) {
     }
 }
 /**
- * What one target actually did. Returns whether anything it was asked to publish failed.
+ * What one target actually did, printed as it is known. Returns the outcome of every package the
+ * *plan* said to publish.
  *
- * An `'error'` is only reported when the *plan* said `'publish'` for that package: an entry that
+ * An `'error'` is only an outcome when the plan said `'publish'` for that package: an entry that
  * was already an error before anything ran has been printed once by `printPlan`, and printing it
  * again under "failed" would read as a push that was attempted and did not work.
  */
 function printApplied(applied, plan, label) {
     const prefix = colors.gray(`[${label}] `);
-    let failed = false;
+    const outcomes = [];
     for (const entry of applied) {
+        if (plan.find(e => e.package === entry.package)?.status !== 'publish')
+            continue;
         if (entry.status === 'publish') {
             console.log(colors.green('published'), prefix + colors.cyan(entry.package.name), entry.detail ?? entry.version);
         }
-        else if (entry.status === 'error' && plan.find(e => e.package === entry.package)?.status === 'publish') {
-            failed = true;
+        else if (entry.status === 'error') {
             console.log(colors.red('failed'), prefix + colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
         }
+        else
+            continue;
+        outcomes.push({ target: label, entry });
+    }
+    return outcomes;
+}
+/**
+ * **One block at the end saying how it went**: how many went up, and every failure again with its
+ * reason. A target prints as it goes, so on a long release the failed line is hundreds of lines up,
+ * among the output of the build that failed - measured on `panates/syncbridge`, where the last
+ * thing in the log was `"publish" failed` and nothing said what.
+ */
+function printRecap(outcomes) {
+    if (!outcomes.length)
+        return;
+    const failed = outcomes.filter(o => o.entry.status === 'error');
+    const published = outcomes.length - failed.length;
+    console.log('\n' +
+        colors.bold('publish') +
+        ' ' +
+        colors.green(`${published} published`) +
+        colors.gray(', ') +
+        (failed.length ? colors.red(`${failed.length} failed`) : colors.gray('0 failed')));
+    for (const { target, entry } of failed) {
+        const [first, ...rest] = (entry.reason ?? '').split('\n');
+        console.log(`  ${colors.red('failed')} ${colors.gray(`[${target}]`)} ${colors.cyan(entry.package.name)} ${entry.version}`);
+        console.log(`         ${colors.red(first ?? '')}`);
+        for (const line of rest)
+            console.log(colors.gray(`       ${line}`));
+    }
+}
+/**
+ * The same outcome as a table on the job's summary page, when running in GitHub Actions - where a
+ * reader looks first, and where a failed release otherwise shows only "exit code 1".
+ *
+ * A no-op outside it (`GITHUB_STEP_SUMMARY` unset), and a summary that cannot be written is not a
+ * reason to fail a publish that worked.
+ */
+function writeStepSummary(outcomes) {
+    const file = process.env.GITHUB_STEP_SUMMARY;
+    if (!file || !outcomes.length)
+        return;
+    const cell = (text) => text.replace(/\|/g, '\\|').replace(/\n+/g, '<br>');
+    const rows = outcomes.map(({ target, entry }) => entry.status === 'error'
+        ? `| ❌ failed | ${target} | \`${entry.package.name}\` | ${entry.version} | ${cell(entry.reason ?? '')} |`
+        : `| ✅ published | ${target} | \`${entry.package.name}\` | ${entry.version} | ${cell(entry.detail ?? '')} |`);
+    const failed = outcomes.filter(o => o.entry.status === 'error').length;
+    const markdown = [
+        `### rman publish - ${outcomes.length - failed} published, ${failed} failed`,
+        '',
+        '| Result | Target | Package | Version | Detail |',
+        '| --- | --- | --- | --- | --- |',
+        ...rows,
+        '',
+    ].join('\n');
+    try {
+        fs.appendFileSync(file, markdown + '\n');
+    }
+    catch {
+        /* The summary is a courtesy; the release itself is what the exit code reports. */
     }
-    return failed;
 }
 /** The `logged` convention: printed here, so `runCli`'s catch does not print it a second time. */
 /* On stderr, because under `--json` stdout is one JSON document: measured on opra's release, the

package/constants.js

@@ -1 +1 @@
-export const version = '2.16.0';
+export const version = '2.18.0';

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

@@ -41,6 +41,11 @@ export interface PublishTarget {
      * Name a flag for the target when it genuinely belongs to one (`--docker-namespace`).
      */
     readonly options?: Record<string, RmanConfig.CommandOption>;
+    /**
+     * Applied after every target without it. For a target whose artifact is built **from** what the
+     * others publish - an image whose `Dockerfile` runs `npm install` - and so has to wait for them.
+     */
+    readonly publishesLast?: boolean;
     /**
      * The technologies this target is for, by `Platform.name` - `['node']` for `npm`. Absent means
      * every platform, which is what a technology-agnostic target says: any package can carry a

package/index.d.ts

@@ -169,6 +169,7 @@ export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';
 export { NodeVersionPlanService } from './builtins/platforms/node/services/version-plan.service.js';
+export { copyAssets, type CopyAssetsOptions, DEFAULT_ASSET_PATTERNS, } from './builtins/platforms/node/utils/copy-assets.js';
 export type { ParsedWorkspaceRange } from './builtins/platforms/node/utils/workspace-range.js';
 export { NPM_TARGET, NpmPublishTarget } from './builtins/publish-targets/npm/npm-publish-target.js';
 export { isCalendarVersion } from './utils/release-version.js';

package/index.js

@@ -135,6 +135,7 @@ export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';
 export { NodeVersionPlanService } from './builtins/platforms/node/services/version-plan.service.js';
+export { copyAssets, DEFAULT_ASSET_PATTERNS, } from './builtins/platforms/node/utils/copy-assets.js';
 export { NPM_TARGET, NpmPublishTarget } from './builtins/publish-targets/npm/npm-publish-target.js';
 export { isCalendarVersion } from './utils/release-version.js';
 export { runBin } from './utils/run-bin.js';

package/interfaces/rman-config.interface.d.ts

@@ -72,6 +72,13 @@ export type CommandEntry = string | CustomCommand | RmanConfig.CommandRegisterFu
 /** One entry of `.rmanrc "publishTargets"` - a target, or a **glob** naming `.js` modules that
  *  `export default` one. */
 export type PublishTargetEntry = string | PublishTarget;
+/**
+ * `.rmanrc "packageManager"`: one entry per technology, by `Platform.name`. Empty here - each
+ * platform that has a package manager to choose adds its own entry by declaration merging, the way
+ * `PublishTargetConfigs` collects the publish targets' blocks.
+ */
+export interface PackageManagers {
+}
 /**
  * **The `.rmanrc` keys no command owns**, without `extends` - kept
  * separate from `RmanConfig` only so the two halves stay legible. A key a *command* owns is
@@ -308,6 +315,11 @@ export interface RmanConfigKeys {
      */
     vars?: Record<string, unknown>;
     logLevel?: 'silent' | 'error' | 'info' | 'verbose';
+    /**
+     * Which package manager each technology uses, keyed by `Platform.name` - `{ node: 'pnpm' }`.
+     * Cascades per package. A technology with no choice to make (Cargo has `cargo`) adds no entry.
+     */
+    packageManager?: PackageManagers;
     allowBranch?: string | string[];
     ignoreBranch?: string | string[];
     /**

package/package.json

@@ -1,33 +1,25 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
+    "@jsopen/objects": "^2.3.4",
     "@netlify/parse-npm-script": "^0.1.2",
     "@xmldom/xmldom": "^0.9.12",
-    "@jsopen/objects": "^2.3.4",
     "ansi-colors": "^4.1.3",
-    "cross-dirname": "^0.1.0",
     "easy-table": "^1.2.0",
     "envinfo": "^7.21.0",
     "fast-glob": "^3.3.3",
-    "fast-tokenizer": "^1.10.0",
+    "fast-tokenizer": "^1.10.1",
     "ini": "^7.0.0",
-    "is-ci": "^4.1.0",
     "js-yaml": "^5.4.1",
     "micromatch": "^4.0.8",
-    "npmlog": "^7.0.1",
     "power-tasks": "^1.14.2",
-    "putil-merge": "^3.13.0",
-    "putil-varhelpers": "^1.7.0",
     "semver": "^7.8.5",
     "signal-exit": "^4.1.0",
-    "strict-typed-events": "^2.8.0",
-    "strip-color": "^0.1.0",
-    "tslib": "^2.8.1",
-    "yargs": "^18.1.0"
+    "yargs": "^18.2.0"
   },
   "type": "module",
   "module": "./index.js",

package/utils/git.js

@@ -228,7 +228,7 @@ export class GitHelper {
     async moveHistory(file) {
         let stdout;
         try {
-            ({ stdout } = await execFileAsync('git', ['log', '--follow', '--format=%x00%H', '--name-status', '--', path.relative(this.cwd, file)], { cwd: this.cwd, maxBuffer: 64 * 1024 * 1024 }));
+            ({ stdout } = await execFileAsync('git', ['log', '--follow', '--format=%x00%H', '--name-status', '--', path.relative(this.cwd, file)], { cwd: this.cwd }));
         }
         catch {
             return [];
@@ -263,7 +263,6 @@ export class GitHelper {
         if (!renames) {
             renames = execFileAsync('git', ['show', '-M', '--name-status', '--format=', sha], {
                 cwd: this.cwd,
-                maxBuffer: 64 * 1024 * 1024,
             }).then(({ stdout }) => stdout
                 .split(/\r?\n/)
                 .map(line => line.split('\t'))
@@ -275,7 +274,6 @@ export class GitHelper {
         try {
             const { stdout } = await execFileAsync('git', ['ls-tree', '-r', '--name-only', `${sha}^`, '--', `${fromDir}/`], {
                 cwd: this.cwd,
-                maxBuffer: 64 * 1024 * 1024,
             });
             held = stdout.split(/\r?\n/).filter(Boolean);
         }
@@ -436,7 +434,7 @@ export class GitHelper {
         if (pathspec)
             args.push('--', pathspec);
         try {
-            const { stdout } = await execFileAsync('git', args, { cwd: this.cwd, maxBuffer: 64 * 1024 * 1024 });
+            const { stdout } = await execFileAsync('git', args, { cwd: this.cwd });
             return stdout;
         }
         catch (e) {
@@ -450,7 +448,6 @@ export class GitHelper {
         try {
             const { stdout } = await execFileAsync('git', ['format-patch', '--root', '-o', outputDir, 'HEAD'], {
                 cwd: this.cwd,
-                maxBuffer: 64 * 1024 * 1024,
             });
             return stdout.trim() ? stdout.trim().split(/\r?\n/) : [];
         }
@@ -465,11 +462,20 @@ export class GitHelper {
         if (!patchFiles.length)
             return;
         try {
-            await execFileAsync('git', ['am', '--3way', ...patchFiles], { cwd: this.cwd, maxBuffer: 64 * 1024 * 1024 });
+            await execFileAsync('git', ['am', '--3way', ...patchFiles], { cwd: this.cwd });
         }
         catch (e) {
             throw new Error(`Unable to apply patches: ${e.message}`, { cause: e });
         }
     }
 }
-const execFileAsync = promisify(execFile);
+/* **One buffer for every git call, not one per call site.** Node's `execFile` defaults `maxBuffer`
+ * to 1 MiB and fails the call past it, and how much git prints depends on the repository, not on
+ * the command. Opting in call by call left the `git show --name-only` behind `listCommittedFiles`
+ * and `listCommits` on the default, so one vendored-library commit in `panates/formwave` - 28k
+ * files, 2.9 MB of names - failed `rman list` with "stdout maxBuffer length exceeded". */
+const GIT_MAX_BUFFER = 64 * 1024 * 1024;
+const execFileP = promisify(execFile);
+function execFileAsync(file, args, options) {
+    return execFileP(file, args, { maxBuffer: GIT_MAX_BUFFER, ...options });
+}