rman 1.0.9 → 1.0.12

package/README.md

@@ -265,11 +265,10 @@ algorithm, prerelease semantics, and `"workspace:"` dependency-range handling.
 
 ### `rman publish`
 
-Publishes every package to its configured target(s) - `npm` by default, or whatever each package's
-own `.rmanrc "publish.target"` says (`"npm"`, `"docker"`, `"github"`, or any combination). Each
-target decides for itself whether the current version is already out there: `npm view` on the npm
-side, `docker manifest inspect` on the docker side, and the GitHub Release for that version's own
-tag on the github side.
+Publishes every package to its configured registry - `npm` by default, or whatever each package's
+own `.rmanrc "publish.target"` says (`"npm"`, `"docker"`, or both). Each target decides for itself
+whether the current version is already out there: `npm view` on the npm side, `docker manifest
+inspect` on the docker side.
 
 ```bash
 rman publish                              # show the plan, then ask for confirmation
@@ -281,7 +280,6 @@ rman publish --otp 123456
 rman publish --registry https://registry.example.com --userconfig ./ci.npmrc
 rman publish --package-manager pnpm
 rman publish --target docker              # only the packages configured for the "docker" target
-rman publish --target github              # only the GitHub Release side of it
 ```
 
 A `"workspace:*"`/`"workspace:^"`/`"workspace:~"` dependency range is automatically rewritten to a
@@ -292,10 +290,19 @@ A package opts into building/pushing a Docker image via `.rmanrc "publish.target
 a `"publish.docker"` block (`image`, `platforms`, `buildContexts`, `buildArgs`, ...) - see
 [docs/cli/publish.md#docker-publishing-publishdocker](docs/cli/publish.md#docker-publishing-publishdocker).
 
-A package with no package registry of its own - a standalone app shipped as release assets, or one
-deployed elsewhere with the release just recording that it shipped - opts into
-`"publish.target": ["github"]` instead, optionally with `"publish.github": { "assets": [...] }` -
-see [docs/cli/publish.md#github-releases-publishgithub](docs/cli/publish.md#github-releases-publishgithub).
+### `rman github-release`
+
+Creates the repository's GitHub Release for the version that just shipped - one per run, named after
+the repository's own release tag, with notes covering every package that shipped under it.
+
+```bash
+rman github-release --yes
+```
+
+It is deliberately neither a `publish.target` nor opt-in: a release isn't a registry a package ships
+to, it's the repository's own record that a version shipped, and every repository wants that record.
+It needs no configuration at all - see
+[docs/cli/github-release.md](docs/cli/github-release.md).
 
 ### `rman import <path>`
 
@@ -320,29 +327,40 @@ precedence: `package.json`'s own `"rman"` key, `.rmanrc.yml` (YAML), `.rmanrc` (
 the dotfile-style name), and `.rmanrc.cjs`/`.rmanrc.mjs`/`.rmanrc.js` for config that needs real
 logic (a JS module's default export).
 
+**Who a declaration is about** follows one rule: unmarked keys configure the package of the
+directory declaring them, and a `"[selector]"` block configures the packages it names. So the
+repository root's own keys are the *root package's* - which is where repo-wide settings are read
+from anyway - and they reach the other packages only through a selector.
+
 ```yaml
 # .rmanrc.yml, at the repository root
 packageManager: pnpm
 logLevel: info
 allowBranch: [main, release/*]
 
-group: true # implicit repo-wide version group by default
-
 version:
   commitMessage: 'chore(release): v{version}'
 
-changelog:
-  ignoreTypes: [chore, ci]
-  tagPattern: 'v*'
-
-run:
-  build:
-    concurrency: 4
-  lint:
-    topo: false
-    bail: false
-  test:
-    changedSince: v1.0.0
+'[*]': # every package in the repository - quotes are required in YAML
+  group: true # implicit repo-wide version group by default
+  changelog:
+    ignoreTypes: [chore, ci]
+    tagPattern: 'v*'
+  clean:
+    include: [build, '../../coverage/${{ pkg.basename }}'] # any string may embed a JS expression
+  run:
+    test: mocha # a bare string is shorthand for { exec: mocha }
+    build:
+      concurrency: 4
+      before: [rman run lint]
+      exec: tsc -b tsconfig-build.json
+      after: node ../../support/postbuild.cjs
+    lint:
+      topo: false
+      bail: false
+
+'[*-dialect]': # a glob over package names, anchored at both ends
+  group: dialects
 ```
 
 ```json
@@ -356,7 +374,7 @@ run:
 ```
 
 See [docs/api.md#configuration-rmanrc-rmanrcyml](docs/api.md#configuration-rmanrc-rmanrcyml) for the
-full key reference (every `run.<script>.*` sub-key, `clean.*`, `changelog.*`, precedence rules,
+full key reference (every `run.<script>.*` sub-key, `clean.*`, `changelog.*`, selector precedence,
 and which keys are root-level-only today).
 
 **Editor autocomplete:** `rman` ships a JSON Schema for `.rmanrc`/`.rmanrc.yml` at

package/cli.js

@@ -11,6 +11,7 @@ import * as ciCommand from './commands/ci.command.js';
 import * as cleanCommand from './commands/clean.command.js';
 import * as diffCommand from './commands/diff.command.js';
 import * as execCommand from './commands/exec.command.js';
+import * as githubReleaseCommand from './commands/github-release.command.js';
 import * as importCommand from './commands/import.command.js';
 import * as infoCommand from './commands/info.command.js';
 import * as listCommand from './commands/list.command.js';
@@ -61,6 +62,7 @@ export async function runCli(options) {
         testCommand.initCli(repository, program);
         versionCommand.initCli(repository, program);
         publishCommand.initCli(repository, program);
+        githubReleaseCommand.initCli(repository, program);
         execCommand.initCli(repository, program);
         changedCommand.initCli(repository, program);
         diffCommand.initCli(repository, program);

package/commands/github-release.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/github-release.command.js

@@ -0,0 +1,119 @@
+import readline from 'node:readline/promises';
+import colors from 'ansi-colors';
+import { GithubReleaseService } from '../services/github-release.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'github-release',
+        describe: "Creates the repository's GitHub Release for the version that just shipped",
+        builder: cmd => applyBranchGuardOptions(cmd)
+            .example('$0 github-release', '# Show what would be released, then ask for confirmation')
+            .example('$0 github-release --yes', '# Create it immediately, no confirmation (CI)')
+            .example('$0 github-release --dry-run', '# Only show the plan')
+            .option('yes', {
+            alias: 'y',
+            describe: 'Skip the confirmation prompt and create the release immediately',
+            type: 'boolean',
+        })
+            .option('dry-run', {
+            describe: 'Only show the plan - never creates anything, regardless of --yes',
+            type: 'boolean',
+        })
+            .option('json', {
+            alias: 'j',
+            describe: 'Print the plan as JSON instead of text',
+            type: 'boolean',
+        })
+            .option('repository', {
+            describe: 'The "owner/repo" the release is created in - default: .rmanrc "githubRelease.repository", ' +
+                'falling back to the "origin" remote.',
+            type: 'string',
+        })
+            .option('ignore-dirty', {
+            describe: 'Release anyway when the working tree has uncommitted changes, instead of aborting',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            // No package filtering: a release belongs to the repository, not to a package, so there is
+            // nothing for --scope/--ignore to narrow down.
+            const plan = await GithubReleaseService.getPlan(repository, {
+                ignoreDirty: args.ignoreDirty,
+                repository: args.repository,
+            });
+            if (args.json) {
+                console.log(JSON.stringify(plan.map(e => ({
+                    tag: e.tag,
+                    repository: e.repository,
+                    status: e.status,
+                    version: e.version,
+                    reason: e.reason,
+                })), undefined, 2));
+            }
+            else {
+                for (const e of plan) {
+                    const name = colors.cyan(e.tag ?? e.version);
+                    switch (e.status) {
+                        case 'publish':
+                            console.log(colors.green('release'), name, colors.gray(`${e.repository} - ${e.reason ?? ''}`));
+                            break;
+                        case 'up-to-date':
+                            console.log(colors.gray('up-to-date'), name, colors.gray(e.reason ?? ''));
+                            break;
+                        case 'skip':
+                            console.log(colors.cyan('skip'), name, colors.gray(e.reason ?? ''));
+                            break;
+                        case 'error':
+                            console.log(colors.red('error'), name, colors.red(e.reason ?? ''));
+                            break;
+                    }
+                }
+            }
+            const error = plan.find(e => e.status === 'error');
+            if (error) {
+                const err = new Error(error.reason ?? 'Unable to prepare the GitHub Release');
+                err.logged = true;
+                throw err;
+            }
+            if (!plan.some(e => e.status === 'publish')) {
+                if (!args.json)
+                    console.log(colors.gray('Nothing to release.'));
+                return;
+            }
+            if (args.dryRun)
+                return;
+            let proceed = !!args.yes;
+            if (!proceed) {
+                if (!process.stdout.isTTY) {
+                    console.log(colors.gray('Not a TTY - refusing to prompt. Pass --yes to release non-interactively.'));
+                    return;
+                }
+                proceed = await confirm('Create this release?');
+            }
+            if (!proceed)
+                return;
+            const applied = await GithubReleaseService.applyPlan(repository, plan);
+            const failed = applied.find(e => e.status === 'error');
+            if (failed) {
+                console.log(colors.red('failed'), colors.cyan(failed.tag ?? ''), colors.red(failed.reason ?? ''));
+                const err = new Error('"github-release" failed');
+                err.logged = true;
+                throw err;
+            }
+            for (const e of applied) {
+                if (e.status === 'publish')
+                    console.log(colors.green('released'), colors.cyan(e.tag ?? ''));
+            }
+        },
+    });
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${question} (y/N) `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}

package/commands/publish.command.js

@@ -2,7 +2,6 @@ import readline from 'node:readline/promises';
 import colors from 'ansi-colors';
 import { CiService } from '../services/ci.service.js';
 import { DockerPublishService } from '../services/docker-publish.service.js';
-import { GithubReleaseService } from '../services/github-release.service.js';
 import { PublishService } from '../services/publish.service.js';
 import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
 import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
@@ -15,7 +14,6 @@ export function initCli(repository, program) {
             .example('$0 publish --yes', '# Publish immediately, no confirmation')
             .example('$0 publish --dry-run', '# Only show the plan, never publish')
             .example('$0 publish --target docker', '# Only the packages configured for the "docker" target')
-            .example('$0 publish --target github', '# Only the GitHub Release side of it')
             .option('yes', {
             alias: 'y',
             describe: 'Skip the confirmation prompt and publish immediately',
@@ -32,12 +30,12 @@ export function initCli(repository, program) {
             type: 'boolean',
         })
             .option('target', {
-            describe: 'Restrict this run to just these publish target(s) ("npm"/"docker"/"github", repeatable) - default: ' +
+            describe: 'Restrict this run to just these publish target(s) ("npm"/"docker", repeatable) - default: ' +
                 'every target each package itself is configured for (.rmanrc "publish.target", "npm" when unset). ' +
                 'A package that opts into "docker" but has no "publish.docker" config errors clearly instead of ' +
                 'being silently skipped.',
             type: 'array',
-            choices: ['npm', 'docker', 'github'],
+            choices: ['npm', 'docker'],
         })
             .option('ignore-dirty', {
             describe: 'Exclude a package with uncommitted local changes instead of aborting the whole run',
@@ -76,18 +74,12 @@ export function initCli(repository, program) {
             describe: 'Prefixed onto a bare (no "/") "publish.docker.image" - default: the DOCKERHUB_NAMESPACE ' +
                 'environment variable.',
             type: 'string',
-        })
-            .option('github-repository', {
-            describe: 'The "owner/repo" GitHub Releases are created in - default: each package\'s own ' +
-                '"publish.github.repository", falling back to the "origin" remote.',
-            type: 'string',
         }),
         handler: async (args) => {
             await assertAllowedBranch(repository, readBranchGuardOptions(args));
             const targets = resolveTargets(args.target);
             const explicitTargets = !!args.target?.length;
             const explicitDockerTarget = explicitTargets && targets.has('docker');
-            const explicitGithubTarget = explicitTargets && targets.has('github');
             const ignoreDirty = args.ignoreDirty;
             const npmOptions = {
                 ...readPackageFilterOptions(args),
@@ -100,23 +92,14 @@ export function initCli(repository, program) {
                 ignoreDirty,
                 namespace: args.dockerNamespace,
             };
-            // No package filtering: a GitHub Release belongs to the repository, not to a package, so
-            // there is nothing for --scope/--ignore to narrow down.
-            const githubOptions = { ignoreDirty, repository: args.githubRepository };
             const npmPlan = targets.has('npm') ? await PublishService.getPlan(repository, npmOptions) : [];
             const dockerPlan = targets.has('docker') ? await DockerPublishService.getPlan(repository, dockerOptions) : [];
-            const githubPlan = targets.has('github') ? await GithubReleaseService.getPlan(repository, githubOptions) : [];
             if (args.json) {
-                console.log(JSON.stringify([
-                    ...npmPlan.map(e => jsonEntry(e, 'npm')),
-                    ...dockerPlan.map(e => jsonEntry(e, 'docker')),
-                    ...githubPlan.map(e => jsonEntry(e, 'github')),
-                ], undefined, 2));
+                console.log(JSON.stringify([...npmPlan.map(e => jsonEntry(e, 'npm')), ...dockerPlan.map(e => jsonEntry(e, 'docker'))], undefined, 2));
             }
             else {
                 printPlan(npmPlan);
                 printPlan(dockerPlan, 'docker');
-                printPlan(githubPlan, 'github');
             }
             if (explicitDockerTarget && !dockerPlan.length) {
                 const message = '--target docker was given, but no package\'s .rmanrc configures "publish.docker".';
@@ -125,14 +108,7 @@ export function initCli(repository, program) {
                 err.logged = true;
                 throw err;
             }
-            if (explicitGithubTarget && !githubPlan.length) {
-                const message = '--target github was given, but nothing in .rmanrc opts into the "github" target.';
-                console.log(colors.red(message));
-                const err = new Error(message);
-                err.logged = true;
-                throw err;
-            }
-            const errors = [...npmPlan, ...dockerPlan, ...githubPlan].filter(e => e.status === 'error');
+            const errors = [...npmPlan, ...dockerPlan].filter(e => e.status === 'error');
             if (errors.length) {
                 const allDirty = errors.every(e => e.reason === 'uncommitted local changes');
                 const message = allDirty
@@ -144,7 +120,7 @@ export function initCli(repository, program) {
                 err.logged = true;
                 throw err;
             }
-            if (![...npmPlan, ...dockerPlan, ...githubPlan].some(e => e.status === 'publish')) {
+            if (![...npmPlan, ...dockerPlan].some(e => e.status === 'publish')) {
                 if (!args.json)
                     console.log(colors.gray('Nothing to publish.'));
                 return;
@@ -172,7 +148,6 @@ export function initCli(repository, program) {
                 })
                 : [];
             const appliedDocker = targets.has('docker') ? await DockerPublishService.applyPlan(repository, dockerPlan) : [];
-            const appliedGithub = targets.has('github') ? await GithubReleaseService.applyPlan(repository, githubPlan) : [];
             let failed = false;
             for (const entry of appliedNpm) {
                 if (entry.status === 'publish') {
@@ -193,16 +168,6 @@ export function initCli(repository, program) {
                     console.log(colors.red('failed'), colors.gray('[docker]'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
                 }
             }
-            for (const entry of appliedGithub) {
-                if (entry.status === 'publish') {
-                    console.log(colors.green('released'), colors.gray('[github]'), colors.cyan(entry.tag ?? ''));
-                }
-                else if (entry.status === 'error' &&
-                    githubPlan.find(e => e.package === entry.package)?.status === 'publish') {
-                    failed = true;
-                    console.log(colors.red('failed'), colors.gray('[github]'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
-                }
-            }
             if (failed) {
                 const err = new Error('"publish" failed');
                 err.logged = true;
@@ -213,7 +178,7 @@ export function initCli(repository, program) {
 }
 function resolveTargets(input) {
     if (!input?.length)
-        return new Set(['npm', 'docker', 'github']);
+        return new Set(['npm', 'docker']);
     return new Set(input);
 }
 /** One `--json` row. `target` is what distinguishes otherwise-identical rows for a package that

package/constants.js

@@ -1 +1 @@
-export const version = '1.0.9';
+export const version = '1.0.12';

package/core/config.d.ts

@@ -1,3 +1,4 @@
+import semver from 'semver';
 import type { RmanConfig } from '../interfaces/rman-config.interface.js';
 /**
  * Identity helper for authoring a `.rmanrc.cjs`/`.mjs`/`.js` config with full type-checking and
@@ -21,10 +22,131 @@ export declare function defineConfig(config: RmanConfig): RmanConfig;
  */
 export declare function readDirConfig(dirname: string): Promise<RmanConfig>;
 /**
- * Resolves the effective config for `targetDir` by cascading from `rootDir`
- * down to `targetDir` (inclusive), the same way tsconfig's `extends` chain
- * works: each directory level overrides the ones above it. This lets a
- * package (or any intermediate directory) narrow or override the repository's
- * root configuration for itself and everything below it.
+ * Resolves the effective config for the package at `targetDir`, cascading from `rootDir` down to
+ * it (inclusive) - each directory level overrides the ones above it, the way tsconfig's `extends`
+ * chain does.
+ *
+ * Every level contributes in two ways, and the difference is the whole model:
+ *
+ * - **Unmarked keys configure the package of the directory that declares them.** The root's own
+ *   `.rmanrc` therefore configures the *root package* - which is where repo-wide settings
+ *   (`packageManager`, `allowBranch`, `version.*`, `githubRelease.*`) are read from anyway - and
+ *   not, silently, every package under it.
+ * - **A `"[selector]"` block configures the packages it names** (`"[*]"` for all of them,
+ *   `"[*-dialect]"` for a glob over package names). This is the only way a directory speaks about
+ *   anything but its own package.
+ *
+ * Splitting the two matters because the same key means different things to the two audiences. The
+ * clearest case is `run.<script>.postScript`: on a package it's that package's build hook, run in
+ * its own directory; on the root it's a repo-wide bookend run once at the repository root. A
+ * cascade that fed one declaration to both ran a package-relative command (`node
+ * ../../support/postbuild.cjs`) at the root, where it cannot resolve.
+ *
+ * `packageName` is what selectors match against; without it (resolving the root's own config, say)
+ * selector blocks contribute nothing at all.
+ */
+export declare function resolveConfig(rootDir: string, targetDir: string, cache?: Map<string, RmanConfig>, packageName?: string): Promise<RmanConfig>;
+/** A config key naming packages rather than settings: `"[*]"`, `"[*-dialect]"`, `"[pkg-a]"`. The
+ *  brackets are what keep this space from colliding with real config keys - no setting starts with
+ *  one - and in YAML they also mean the key always needs quoting (`"[*]":`), since a bare `[*]`
+ *  parses as a flow sequence. */
+export declare function isSelectorKey(key: string): boolean;
+/** The glob inside a selector key, as a `RegExp` anchored at both ends - so `"[*-dialect]"` matches
+ *  `mysql-dialect` but not `my-dialect-helper`. Glob rather than regex, to match every other
+ *  pattern in rman (`allowBranch`, `changelog.tagPattern`, `clean.include`). */
+export declare function selectorToRegExp(key: string): RegExp;
+/** One package, as an expression sees it - the same shape for the package the config belongs to
+ *  and for the repository itself, so `${{ repository.basename }}` reads the way `${{ pkg.basename }}` does. */
+export interface PackageScope {
+    /** The package's own name, scope included (`@sqb/builder`). */
+    name: string;
+    /** Just the scope (`@sqb`), or `undefined` for an unscoped package. */
+    scope: string | undefined;
+    /** The name with its scope stripped (`builder`). */
+    unscopedName: string;
+    version: string;
+    /** The package directory's last segment (`builder`) - not always the same as `unscopedName`,
+     *  which is why both exist, and usually what a sibling path (`../../coverage/builder`) is keyed on. */
+    basename: string;
+    /** Absolute path to the package's own directory - named as rman's own `Package.dirname` is. */
+    dirname: string;
+    /** That directory relative to the repository root (`packages/builder`), which is what a command
+     *  addressing another package from the root usually needs. Empty string for the root itself. */
+    relativeDir: string;
+    /** The whole `package.json`, as a copy - so an expression can reach a field rman itself has no
+     *  opinion about (`pkg.json.engines.node`). */
+    json: Record<string, unknown>;
+}
+/** Facts about the repository, on top of the root package's own - because the repository root *is*
+ *  a package (`repository.name` is what its `package.json` says, `repository.basename` the directory
+ *  it sits in, and the two genuinely differ). Sharing `PackageScope`'s shape is what makes
+ *  `repository.version` read the way `pkg.version` does. */
+export interface RepositoryScope extends PackageScope {
+    monorepo: boolean;
+    /** Every package in the repository - the root included only when it *is* the one package. */
+    packages: PackageScope[];
+    /** One package by name, or `undefined` - for reaching a sibling's directory. */
+    package(name: string): PackageScope | undefined;
+    /** Read from git only if an expression actually asks for it, then remembered: a repository that
+     *  never mentions these pays nothing, and every command resolves config. All `undefined` outside
+     *  a git checkout, which is a legitimate state rather than an error. */
+    git: GitScope;
+}
+export interface GitScope {
+    branch: string | undefined;
+    sha: string | undefined;
+    shortSha: string | undefined;
+    /** Whether the working tree has uncommitted changes. */
+    dirty: boolean | undefined;
+}
+/** What a `${{ ... }}` expression can see - the bindings of the fresh global it is evaluated in.
+ *  Namespaced rather than a flat bag of loose names: one obvious place per fact, and room to add
+ *  helpers to `pkg`/`repository` later without crowding the global. */
+export interface ConfigScope {
+    /** The package the config was resolved for - which is what lets one declaration at the root
+     *  still say something package-specific. */
+    pkg: PackageScope;
+    repository: RepositoryScope;
+    env: Record<string, string | undefined>;
+    /** rman's own `semver`, for the arithmetic every release config eventually wants
+     *  (`semver.major(pkg.version)`). */
+    semver: typeof semver;
+}
+/**
+ * Evaluates every `${{ ... }}` expression in **every** string value of a resolved config, against
+ * the package it was resolved for:
+ *
+ * ```yaml
+ * "[*]":
+ *   clean:
+ *     include: ["build", "../../coverage/${{ pkg.basename }}"]
+ *   publish:
+ *     docker:
+ *       image: "panates/${{ pkg.basename }}:${{ semver.major(pkg.version) }}"
+ * ```
+ *
+ * Every string, with no list of "interpolated keys" to memorize - a rule with exceptions is a rule
+ * nobody remembers.
+ *
+ * The contents are **real JavaScript**, not a template mini-language, so there is no growing list
+ * of substitutions to keep adding (`{{major}}`, `{{scope}}`, ...) - see `ConfigScope` for what is
+ * in scope.
+ *
+ * **`${{ }}`, deliberately not `{{ }}`.** A config value may legitimately carry `{{...}}` meant for
+ * something else entirely (`helm template --set tag={{.Values.tag}}`); with the plainer delimiter
+ * rman would try to evaluate it. To emit a literal, let an expression produce it, the way GitHub
+ * Actions does: `${{ '${{' }}`.
+ *
+ * A string that is *nothing but* one expression keeps the value's own type (`"${{ pkg.private }}"`
+ * -> a boolean), since otherwise this could only ever produce strings and settings like
+ * `run.<script>.skip` would be unreachable. Embedded in surrounding text it is stringified.
+ *
+ * Evaluation happens in a fresh V8 context holding only the scope's bindings. That is a clean
+ * scope, **not a sandbox** - `node:vm` is explicitly not a security mechanism, and no sandbox is
+ * called for here anyway: a `.rmanrc` that can say `exec: "..."` already runs arbitrary shell, so
+ * the expression evaluator adds no trust boundary that wasn't already wide open.
+ *
+ * A failing expression throws with the config path that holds it, rather than being left in place:
+ * silently passing through a mistake is how a config ends up quietly doing nothing.
  */
-export declare function resolveConfig(rootDir: string, targetDir: string, cache?: Map<string, RmanConfig>): Promise<RmanConfig>;
+export declare function interpolateConfig<T>(config: T, scope: ConfigScope): T;