rman 1.2.5 → 2.0.0-beta.2

package/services/run.service.js

@@ -3,221 +3,31 @@ import { inspect } from 'node:util';
 import colors from 'ansi-colors';
 import { tokenize } from 'fast-tokenizer';
 import { Task } from 'power-tasks';
+import { Service } from '../core/service.js';
 import { exec } from '../utils/exec.js';
 import { LOG_LEVELS, Logger, resolveRootLogLevel } from '../utils/logger.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { ProgressPanel } from '../utils/progress-panel.js';
 import { runBin } from '../utils/run-bin.js';
-export var RunService;
-(function (RunService) {
-    /**
-     * Registers a source. Called by `loadPlugins` for each plugin's `runSteps`, in `plugins`
-     * declaration order - never as an import side effect, so what is registered is exactly what the
-     * repository's `.rmanrc` asked for.
-     */
-    function addStepSource(source) {
-        /** Idempotent per source: a plugin both declares `runSteps` (registered by `loadPlugins`) and
-         *  may call its own `augmentRun()` for programmatic callers, so the same function arrives
-         *  twice. Pushing twice is harmless - the first match wins - but it makes the registry lie
-         *  about what is in it. */
-        if (stepSources.includes(source))
-            return;
-        stepSources.push(source);
-    }
-    RunService.addStepSource = addStepSource;
-    /** For tests, which would otherwise leak a source into every later case in the process. */
-    function clearStepSources() {
-        stepSources.length = 0;
-    }
-    RunService.clearStepSources = clearStepSources;
-    /**
-     * What the *package itself* declares for the lifecycle `script`, from the contributed sources
-     * alone - no `.rmanrc` involved. `undefined` when it declares nothing.
-     *
-     * Exported because `run` is not the only lifecycle rman wraps: `version` runs hooks around the
-     * version write, and npm spells those `preversion`/`version`/`postversion` in `package.json` -
-     * which is the same `pre<script>`/`<script>`/`post<script>` shape a step source already answers.
-     * So `VersionService` asks here for `'version'` instead of reading `manifest.raw.scripts` itself,
-     * and npm's version lifecycle keeps working with no second seam and no extra line in any plugin.
-     * A plugin for another ecosystem gets its own lifecycle hooks the moment it contributes steps.
-     */
-    function contributedSlots(pkg, script) {
-        return firstContributed(pkg, script);
-    }
-    RunService.contributedSlots = contributedSlots;
-    /**
-     * Runs one slot of a lifecycle belonging to some operation other than `run` itself - `version`'s
-     * hooks around the version write are the only one so far.
-     *
-     * **Here rather than in `VersionService`, because the rule it applies is this service's**: the
-     * package's own declaration for `script` wins over the caller's `fallback`, slot by slot, exactly
-     * as `getScriptSteps` decides it for `run`. Kept in two places that rule would drift, and one of
-     * the copies would sit in the file that writes versions - which now runs no command of its own at
-     * all.
-     *
-     * `fallback` is the caller's own configured step(s), **already evaluated**: `version`'s three
-     * paths are in `DEFERRED_PATHS` precisely because only the caller can bind
-     * `${{ pkg.targetVersion }}`, so interpolating here would either be too early or need a scope this
-     * service has no business holding.
-     *
-     * **A list, not one joined string.** `VersionService` used to `join(' && ')` an array into a
-     * single shell line, which a function step cannot be part of - and which quietly changed the
-     * semantics of the shell case too, since `cd x && y` in one process is not the same as two.
-     */
-    async function runLifecycleSlot(pkg, script, slot, fallback) {
-        const own = contributedSlots(pkg, script)?.[slot] ?? [];
-        const values = own.length ? own : (fallback ?? []);
-        for (const value of values) {
-            if (typeof value === 'function') {
-                await value(createStepContext(pkg, pkg.dirname));
-                continue;
-            }
-            await exec(value, { cwd: pkg.dirname, stdio: 'inherit' });
-        }
-    }
-    RunService.runLifecycleSlot = runLifecycleSlot;
-    function getConfig(pkg, script) {
-        const runCfg = pkg.config?.run;
-        const cfg = runCfg && typeof runCfg === 'object' ? runCfg[script] : undefined;
-        /** The bare-value shorthand. A function is `typeof 'function'`, not `'object'`, so without
-         *  naming it here `run: { build: myFn }` fell through to the `{}` below - the long form would
-         *  have worked and the short one silently done nothing, an arbitrary difference. */
-        if (typeof cfg === 'string' || typeof cfg === 'function' || Array.isArray(cfg))
-            return { exec: cfg };
-        return cfg && typeof cfg === 'object' ? cfg : {};
-    }
-    RunService.getConfig = getConfig;
-    /**
-     * The context a function step or `if` is handed - see [`RunStepContext`](../core/run-step.ts).
-     *
-     * `runBin` and `logger` are bound to *this run* rather than left to be imported, which is the
-     * whole reason they are handed over: an imported `runBin` knows neither the cwd nor the resolved
-     * log level.
-     */
-    /**
-     * A `run.<script>.before`/`.exec`/`.after` (or `version.<slot>`) value: one step, or several to
-     * run in sequence. A shell command or a function, and a list may mix them.
-     *
-     * **Anything else throws, naming the path.** It used to `return []`, which meant a value rman did
-     * not recognize was dropped with no trace: writing a function here - the obvious guess, and now
-     * the supported form - produced `1 succeeded, 0 failed` with the step never run (measured). A
-     * configuration mistake has to be loud; silence here reads as success.
-     *
-     * Exported, and the only implementation: `VersionService` used to carry a second one that behaved
-     * differently, which is how `version.<slot>` came to join its array with `' && '`.
-     */
-    function normalizeScriptValue(value, at) {
-        const items = Array.isArray(value) ? value : [value];
-        const steps = [];
-        for (let i = 0; i < items.length; i++) {
-            const item = items[i];
-            /** An empty string and an absent value are both "nothing here", which is how a `"[*]"` block
-             *  declaring a slot some packages don't use has always behaved. */
-            if (item === undefined || item === null || item === '')
-                continue;
-            if (typeof item === 'string' || typeof item === 'function') {
-                steps.push(item);
-                continue;
-            }
-            const where = Array.isArray(value) ? `${at}[${i}]` : at;
-            throw new Error(`"${where}" must be a shell command or a function, but it is ${describeValue(item)}.\n` +
-                `  A list of either (or both) runs them in sequence.`);
-        }
-        return steps;
-    }
-    RunService.normalizeScriptValue = normalizeScriptValue;
-    function createStepContext(pkg, cwd) {
-        const logLevel = resolveRootLogLevel(pkg.repository);
-        return {
-            pkg,
-            repository: pkg.repository,
-            cwd,
-            runBin: (bin, argv, opts) => runBin(bin, argv, { cwd, logLevel, ...opts }),
-            logger: new Logger(logLevel),
-        };
-    }
-    RunService.createStepContext = createStepContext;
-    function resolveEnvPlaceholders(value) {
-        return value.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => process.env[name] ?? '');
-    }
-    /** Recursive-descent parser over `tokenizeIf`'s output: expr := or ; or := and ('or' and)* ;
-     *  and := unary ('and' unary)* ; unary := 'not' unary | GROUP | NAME ['=' VALUE] */
-    function parseIfExpr(raw) {
-        if (typeof raw !== 'string' || !raw.trim())
-            return undefined;
-        const tokens = tokenizeIf(raw);
-        if (!tokens.length)
-            return undefined;
-        let i = 0;
-        const peek = () => tokens[i];
-        const next = () => tokens[i++];
-        function parseUnary() {
-            if (peek()?.toLowerCase() === 'not') {
-                next();
-                return { kind: 'not', node: parseUnary() };
-            }
-            const tok = next() ?? '';
-            /** A token containing whitespace can only be a collapsed `(...)` group - plain
-             *  atom/operator tokens never do, since they're themselves split on whitespace. */
-            if (/\s/.test(tok)) {
-                const inner = parseIfExpr(tok);
-                if (!inner)
-                    throw new Error(`Empty group in "if" expression: "${raw}"`);
-                return inner;
-            }
-            let value;
-            if (peek() === '=') {
-                next();
-                value = resolveEnvPlaceholders(next() ?? '');
-            }
-            return { kind: 'atom', name: tok, value };
-        }
-        function parseAnd() {
-            let node = parseUnary();
-            while (peek()?.toLowerCase() === 'and') {
-                next();
-                node = { kind: 'and', left: node, right: parseUnary() };
-            }
-            return node;
-        }
-        function parseOr() {
-            let node = parseAnd();
-            while (peek()?.toLowerCase() === 'or') {
-                next();
-                node = { kind: 'or', left: node, right: parseAnd() };
-            }
-            return node;
-        }
-        return parseOr();
-    }
-    RunService.parseIfExpr = parseIfExpr;
-    /** Evaluates a parsed `if` expression for one package. `statusCache` avoids repeat `git` calls
-     *  for the same reference hash across packages/scripts in a single run. */
-    async function evaluateIf(repository, pkg, node, statusCache) {
-        if (node.kind === 'and') {
-            if (!(await evaluateIf(repository, pkg, node.left, statusCache)))
-                return false;
-            return evaluateIf(repository, pkg, node.right, statusCache);
-        }
-        if (node.kind === 'or') {
-            if (await evaluateIf(repository, pkg, node.left, statusCache))
-                return true;
-            return evaluateIf(repository, pkg, node.right, statusCache);
-        }
-        if (node.kind === 'not') {
-            return !(await evaluateIf(repository, pkg, node.node, statusCache));
-        }
-        return evaluateIfAtom(repository, pkg, node.name, node.value, statusCache);
-    }
-    RunService.evaluateIf = evaluateIf;
-    async function runScript(repository, script, options = {}) {
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had.
+ *
+ * **Only `runScript` became a method**, because only it takes a repository. `getConfig`,
+ * `parseIfExpr`, `normalizeScriptValue` and the rest take a `Package` or a raw value and stay
+ * functions on the namespace below - the same rule that leaves `ChangeHashService` a namespace
+ * entirely. Declared before the namespace, which TypeScript requires for the merge.
+ */
+export class RunService extends Service {
+    async runScript(script, options = {}) {
+        const repository = this.repository;
         const commandName = options.commandName || 'run';
-        const rootCfg = getConfig(repository.rootPackage, script);
+        const rootCfg = RunService.getConfig(repository.rootPackage, script);
         const logLevelDefault = resolveRootLogLevel(repository);
         /** Standing inside a single package's own directory scopes the run to just that package
-         *  (and drops the root bookend below) unless `--root` asks for the whole repository anyway -
+         *  (and drops the root bookend below) unless `--from-root` asks for the whole repository anyway -
          *  a no-op when already at the root, or outside any known package. */
-        const cwdScope = options.root ? undefined : repository.currentPackage;
+        const cwdScope = options.fromRoot ? undefined : repository.currentPackage;
         /** Global fallback for topo - individual packages can still override their own linking below,
          *  but the initial sort (topological vs alphabetical) has to be decided for the whole list at once. */
         const topo = resolveBool(options.topo, repository.rootPackage, script, 'topo', true);
@@ -260,7 +70,7 @@ export var RunService;
                         if (step.run)
                             await runFunctionStep(step.run, pkg, cwd, onLine);
                         else
-                            await exec(step.command, { cwd, stdio: 'pipe', onLine });
+                            await exec(step.command, { cwd, stdio: 'pipe', onLine, app: pkg.repository.app });
                     }
                     else {
                         /** Match the classic rman output: raw command output streams straight through
@@ -274,10 +84,23 @@ export var RunService;
                             if (step.run)
                                 await runFunctionStep(step.run, pkg, cwd);
                             else
-                                await exec(step.command, { cwd, stdio: 'inherit' });
+                                await exec(step.command, { cwd, stdio: 'inherit', app: pkg.repository.app });
                         }
                         catch (e) {
-                            stepError = e;
+                            /**
+                             * **Normalized to an `Error`, because a *falsy* throw was indistinguishable from no
+                             * failure at all.** This was `let stepError: any` with `if (stepError) throw
+                             * stepError` below, so a step doing `throw undefined` - legal JavaScript, and what a
+                             * rejected promise carrying nothing gives you - left `stepError` falsy: the step
+                             * line printed **success**, nothing was rethrown, and the run exited 0. Found by the
+                             * spec written for the message-reporting fix above, which is the only reason it is
+                             * not still there. A step that fails while reporting success is the one outcome this
+                             * slot exists to rule out.
+                             *
+                             * Only the panel-off path had it: with the panel on there is no local catch, and the
+                             * outer one runs whatever was thrown.
+                             */
+                            stepError = e instanceof Error ? e : new Error(messageOf(e));
                         }
                         printLegacyStepLine(commandName, pkgLabel, step, Date.now() - stepStart, pkgLogLevel, stepError);
                         if (stepError)
@@ -331,7 +154,7 @@ export var RunService;
         }
         const stepsByPackage = new Map();
         for (const pkg of packages) {
-            const pkgCfg = getConfig(pkg, script);
+            const pkgCfg = RunService.getConfig(pkg, script);
             if (pkgCfg.skip === true)
                 continue;
             if (!(await passesIf(repository, pkg, pkgCfg.if, pkg.dirname, ifStatusCache)))
@@ -431,7 +254,188 @@ export var RunService;
             throw err;
         }
     }
-    RunService.runScript = runScript;
+}
+(function (RunService) {
+    /**
+     * What the *package itself* declares for the lifecycle `script`, from the contributed sources
+     * alone - no `.rmanrc` involved. `undefined` when it declares nothing.
+     *
+     * Exported because `run` is not the only lifecycle rman wraps: `version` runs hooks around the
+     * version write, and npm spells those `preversion`/`version`/`postversion` in `package.json` -
+     * which is the same `pre<script>`/`<script>`/`post<script>` shape a step source already answers.
+     * So `VersionService` asks here for `'version'` instead of reading `manifest.raw.scripts` itself,
+     * and npm's version lifecycle keeps working with no second seam and no extra line in any plugin.
+     * A plugin for another ecosystem gets its own lifecycle hooks the moment it contributes steps.
+     */
+    function contributedSlots(pkg, script) {
+        return contributedSlotsFor(pkg, script);
+    }
+    RunService.contributedSlots = contributedSlots;
+    /**
+     * Runs one slot of a lifecycle belonging to some operation other than `run` itself - `version`'s
+     * hooks around the version write are the only one so far.
+     *
+     * **Here rather than in `VersionService`, because the rule it applies is this service's**: the
+     * package's own declaration for `script` wins over the caller's `fallback`, slot by slot, exactly
+     * as `getScriptSteps` decides it for `run`. Kept in two places that rule would drift, and one of
+     * the copies would sit in the file that writes versions - which now runs no command of its own at
+     * all.
+     *
+     * `fallback` is the caller's own configured step(s), **already evaluated**: `version`'s three
+     * paths are in `DEFERRED_PATHS` precisely because only the caller can bind
+     * `${{ pkg.targetVersion }}`, so interpolating here would either be too early or need a scope this
+     * service has no business holding.
+     *
+     * **A list, not one joined string.** `VersionService` used to `join(' && ')` an array into a
+     * single shell line, which a function step cannot be part of - and which quietly changed the
+     * semantics of the shell case too, since `cd x && y` in one process is not the same as two.
+     */
+    async function runLifecycleSlot(pkg, script, slot, fallback) {
+        const own = contributedSlots(pkg, script)?.[slot] ?? [];
+        const values = own.length ? own : (fallback ?? []);
+        for (const value of values) {
+            if (typeof value === 'function') {
+                await value(createStepContext(pkg, pkg.dirname));
+                continue;
+            }
+            await exec(value, { cwd: pkg.dirname, stdio: 'inherit', app: pkg.repository.app });
+        }
+    }
+    RunService.runLifecycleSlot = runLifecycleSlot;
+    function getConfig(pkg, script) {
+        const runCfg = pkg.config?.run;
+        const cfg = runCfg && typeof runCfg === 'object' ? runCfg[script] : undefined;
+        /** The bare-value shorthand. A function is `typeof 'function'`, not `'object'`, so without
+         *  naming it here `run: { build: myFn }` fell through to the `{}` below - the long form would
+         *  have worked and the short one silently done nothing, an arbitrary difference. */
+        if (typeof cfg === 'string' || typeof cfg === 'function' || Array.isArray(cfg))
+            return { exec: cfg };
+        return cfg && typeof cfg === 'object' ? cfg : {};
+    }
+    RunService.getConfig = getConfig;
+    /**
+     * The context a function step or `if` is handed - see [`RunStepContext`](../core/run-step.ts).
+     *
+     * `runBin` and `logger` are bound to *this run* rather than left to be imported, which is the
+     * whole reason they are handed over: an imported `runBin` knows neither the cwd nor the resolved
+     * log level.
+     */
+    /**
+     * A `run.<script>.before`/`.exec`/`.after` (or `version.<slot>`) value: one step, or several to
+     * run in sequence. A shell command or a function, and a list may mix them.
+     *
+     * **Anything else throws, naming the path.** It used to `return []`, which meant a value rman did
+     * not recognize was dropped with no trace: writing a function here - the obvious guess, and now
+     * the supported form - produced `1 succeeded, 0 failed` with the step never run (measured). A
+     * configuration mistake has to be loud; silence here reads as success.
+     *
+     * Exported, and the only implementation: `VersionService` used to carry a second one that behaved
+     * differently, which is how `version.<slot>` came to join its array with `' && '`.
+     */
+    function normalizeScriptValue(value, at) {
+        const items = Array.isArray(value) ? value : [value];
+        const steps = [];
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            /** An empty string and an absent value are both "nothing here", which is how a `"[*]"` block
+             *  declaring a slot some packages don't use has always behaved. */
+            if (item === undefined || item === null || item === '')
+                continue;
+            if (typeof item === 'string' || typeof item === 'function') {
+                steps.push(item);
+                continue;
+            }
+            const where = Array.isArray(value) ? `${at}[${i}]` : at;
+            throw new Error(`"${where}" must be a shell command or a function, but it is ${describeValue(item)}.\n` +
+                `  A list of either (or both) runs them in sequence.`);
+        }
+        return steps;
+    }
+    RunService.normalizeScriptValue = normalizeScriptValue;
+    function createStepContext(pkg, cwd) {
+        const logLevel = resolveRootLogLevel(pkg.repository);
+        return {
+            pkg,
+            repository: pkg.repository,
+            cwd,
+            runBin: (bin, argv, opts) => runBin(bin, argv, { cwd, logLevel, app: pkg.repository.app, ...opts }),
+            logger: new Logger(logLevel),
+        };
+    }
+    RunService.createStepContext = createStepContext;
+    function resolveEnvPlaceholders(value) {
+        return value.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => process.env[name] ?? '');
+    }
+    /** Recursive-descent parser over `tokenizeIf`'s output: expr := or ; or := and ('or' and)* ;
+     *  and := unary ('and' unary)* ; unary := 'not' unary | GROUP | NAME ['=' VALUE] */
+    function parseIfExpr(raw) {
+        if (typeof raw !== 'string' || !raw.trim())
+            return undefined;
+        const tokens = tokenizeIf(raw);
+        if (!tokens.length)
+            return undefined;
+        let i = 0;
+        const peek = () => tokens[i];
+        const next = () => tokens[i++];
+        function parseUnary() {
+            if (peek()?.toLowerCase() === 'not') {
+                next();
+                return { kind: 'not', node: parseUnary() };
+            }
+            const tok = next() ?? '';
+            /** A token containing whitespace can only be a collapsed `(...)` group - plain
+             *  atom/operator tokens never do, since they're themselves split on whitespace. */
+            if (/\s/.test(tok)) {
+                const inner = parseIfExpr(tok);
+                if (!inner)
+                    throw new Error(`Empty group in "if" expression: "${raw}"`);
+                return inner;
+            }
+            let value;
+            if (peek() === '=') {
+                next();
+                value = resolveEnvPlaceholders(next() ?? '');
+            }
+            return { kind: 'atom', name: tok, value };
+        }
+        function parseAnd() {
+            let node = parseUnary();
+            while (peek()?.toLowerCase() === 'and') {
+                next();
+                node = { kind: 'and', left: node, right: parseUnary() };
+            }
+            return node;
+        }
+        function parseOr() {
+            let node = parseAnd();
+            while (peek()?.toLowerCase() === 'or') {
+                next();
+                node = { kind: 'or', left: node, right: parseAnd() };
+            }
+            return node;
+        }
+        return parseOr();
+    }
+    RunService.parseIfExpr = parseIfExpr;
+    /** Evaluates a parsed `if` expression for one package. `statusCache` avoids repeat `git` calls
+     *  for the same reference hash across packages/scripts in a single run. */
+    async function evaluateIf(repository, pkg, node, statusCache) {
+        if (node.kind === 'and') {
+            if (!(await evaluateIf(repository, pkg, node.left, statusCache)))
+                return false;
+            return evaluateIf(repository, pkg, node.right, statusCache);
+        }
+        if (node.kind === 'or') {
+            if (await evaluateIf(repository, pkg, node.left, statusCache))
+                return true;
+            return evaluateIf(repository, pkg, node.right, statusCache);
+        }
+        if (node.kind === 'not') {
+            return !(await evaluateIf(repository, pkg, node.node, statusCache));
+        }
+        return evaluateIfAtom(repository, pkg, node.name, node.value, statusCache);
+    }
+    RunService.evaluateIf = evaluateIf;
 })(RunService || (RunService = {}));
 /**
  * Classic one-line-per-step log ("info build pkg ┆ step success ┆ command  (123 ms)"),
@@ -483,11 +487,30 @@ function toStep(slot, value) {
  *
  * Restored in a `finally`, because a step that throws must not leave the rest of the run writing
  * into a log nobody reads.
+ *
+ * **Its failure message is reported here, because nothing else does it.** A shell step's reason
+ * reaches the user on its own - the output streams through `onLine` or straight to the terminal,
+ * and `exec` names the command and its exit code. A function step has neither: it fails by
+ * throwing, and the throw goes to the outer `catch` that marks the package failed and rethrows an
+ * error the CLI treats as already-logged. Measured on a real config whose build step threw a
+ * carefully worded message about a missing `tsconfig.json`: the run printed
+ * `error build pkg-forgot ┆ exec failed ┆ buildWithTsc` and exited 1, and the message appeared
+ * nowhere at all - so the one thing that said what to do was the one thing dropped.
+ *
+ * Written where a shell step's output goes, so it needs no second channel: through `onLine` with
+ * the panel on (the step's own log, which is what the panel shows for a failed item), and to
+ * stderr with it off, ahead of the `failed` line - the order a shell step already produces.
  */
 async function runFunctionStep(run, pkg, cwd, onLine) {
     const context = RunService.createStepContext(pkg, cwd);
     if (!onLine) {
-        await run(context);
+        try {
+            await run(context);
+        }
+        catch (e) {
+            console.error(colors.red(messageOf(e)));
+            throw e;
+        }
         return;
     }
     const console_ = globalThis.console;
@@ -504,11 +527,24 @@ async function runFunctionStep(run, pkg, cwd, onLine) {
     try {
         await run(context);
     }
+    catch (e) {
+        /** Through the patched `console` deliberately - `onLine` is still installed at this point, so
+         *  the message lands in this step's log rather than over the panel it is drawn inside. */
+        for (const line of messageOf(e).split('\n'))
+            onLine(line);
+        throw e;
+    }
     finally {
         for (const method of CAPTURED_CONSOLE)
             console_[method] = original[method];
     }
 }
+/** What a thrown value has to say for itself. A step may throw anything, and `String(undefined)`
+ *  reading as `undefined` in a run log is worse than saying nothing was said. */
+function messageOf(error) {
+    const message = error instanceof Error ? error.message : typeof error === 'string' ? error : '';
+    return message.trim() || `the step threw ${inspect(error)}`;
+}
 const CAPTURED_CONSOLE = ['log', 'info', 'warn', 'error', 'debug'];
 function format(args) {
     return args.map(arg => (typeof arg === 'string' ? arg : inspect(arg))).join(' ');
@@ -549,7 +585,7 @@ async function passesIf(repository, pkg, raw, cwd, statusCache) {
 function getScriptSteps(pkg, script) {
     const cfg = RunService.getConfig(pkg, script);
     const override = cfg.override === true;
-    const contributed = firstContributed(pkg, script);
+    const contributed = contributedSlotsFor(pkg, script);
     const fromConfig = {
         before: RunService.normalizeScriptValue(cfg.before, `run.${script}.before`),
         exec: RunService.normalizeScriptValue(cfg.exec, `run.${script}.exec`),
@@ -565,19 +601,22 @@ function getScriptSteps(pkg, script) {
     }
     return steps;
 }
-/** The first source that says this package declares the script at all. Declaration order, so a
- *  repository listing two plugins gets a predictable answer rather than a merged one. */
-function firstContributed(pkg, script) {
-    for (const source of stepSources) {
-        const slots = source(pkg, script);
-        if (slots && (slots.before?.length || slots.exec?.length || slots.after?.length))
-            return slots;
-    }
-    return undefined;
+/**
+ * What this package's own technology says it declares for `script`.
+ *
+ * **Its own, not every registered one.** This walked all the contributed sources and took the first
+ * that answered, which in a polyglot repository meant npm's `package.json#scripts` reader was handed
+ * a Cargo package and asked whether it declared `build` - its first line is
+ * `pkg.manifest.raw?.scripts`, so it was reading a manifest another technology produced. The package
+ * already knows which technology claimed it; asking anyone else was only ever a way of finding that
+ * out again.
+ */
+function contributedSlotsFor(pkg, script) {
+    const slots = pkg.platform.getRunSteps?.(pkg, script);
+    return slots && (slots.before?.length || slots.exec?.length || slots.after?.length) ? slots : undefined;
 }
 /** In execution order - `before`, the script itself, then `after`. */
 const SCRIPT_SLOTS = ['before', 'exec', 'after'];
-const stepSources = [];
 /**
  * Splits on whitespace, but a `(...)` group collapses to a single token holding its inner text
  * (parens stripped, inner whitespace kept) - `evaluate` below re-tokenizes any token that still

package/services/version-plan.service.d.ts

@@ -1,3 +1,4 @@
+import { RmanApplication } from '../core/application.js';
 import type { Package } from '../core/package.js';
 import type { Repository } from '../core/repository.js';
 import { VersionScheme } from '../core/version-scheme.js';
@@ -97,6 +98,31 @@ export declare abstract class VersionPlanService {
      * wrong one here is invisible - it produces a plan that simply releases too little.
      */
     protected abstract cascade(bump: string): VersionPlanService.Cascade;
+    /**
+     * **Which planner answers for one package: its own technology's.**
+     *
+     * The two abstract members above are the ecosystem's, and a repository can hold more than one.
+     * `app.versionPlanner` is a single slot - last registration wins - so in a polyglot repository
+     * both of them used to be answered by whichever plugin happened to register last: a Cargo
+     * package's boundary fell back to `npm view`, and its cascade assumed npm's caret ranges. That is
+     * the same shape of bug the hardcoded `['npm']` publish default was, and the same fix - ask the
+     * technology that read the manifest.
+     *
+     * Falls back to `this`, which is what a single-technology repository always gets and what a
+     * `Plugin` contributing no planner of its own means.
+     */
+    protected plannerFor(pkg: Package): VersionPlanService;
+    /**
+     * `cascade` for a whole group, which is the unit it is asked about - one answer applies to every
+     * member, because the group releases as one version line.
+     *
+     * **Members disagreeing take the widest answer**, and the direction is deliberate: a cascade that
+     * is too narrow produces a plan that silently *releases too little* (the failure `cascade`'s own
+     * doc calls invisible), while one that is too wide releases a package that did not strictly need
+     * it - visible, and harmless. A mixed-technology group is unusual; a mixed group quietly skipping
+     * a dependent that pins exact versions is a broken install.
+     */
+    protected cascadeFor(members: Package[], bump: string): VersionPlanService.Cascade;
     /**
      * The largest bump `commits` ask for, in `scheme`'s own names.
      *
@@ -230,9 +256,6 @@ export declare namespace VersionPlanService {
      * repository layering its own policy plugin after `rman-node` could never take effect - which is
      * the only reason to name two in the first place.
      */
-    function setPlanner(planner: VersionPlanService): void;
-    /** For tests, which would otherwise leak a planner into every later case in the process. */
-    function clearPlanner(): void;
     /**
      * The registered planner. **Throws** when there is none, rather than falling back to some
      * built-in default: `Manifest` and `Workspace` can degrade honestly (a package named after its
@@ -240,5 +263,5 @@ export declare namespace VersionPlanService {
      * merely a diminished one - a wrong cascade or a wrong boundary reports a release that is
      * plausible and untrue.
      */
-    function getPlanner(): VersionPlanService;
+    function getPlanner(app: RmanApplication): VersionPlanService;
 }