rman 2.6.1 → 2.8.0

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

@@ -72,6 +72,7 @@ export var CiService;
         const progress = options.progress ?? true;
         const panel = new ProgressPanel('CI', !!process.stdout.isTTY && progress);
         const runStartedAt = Date.now();
+        panel.detail = repository.name;
         panel.start(repository.app.statusRegion);
         const items = [];
         let failed = false;
@@ -122,6 +123,9 @@ const LOCK_FILES = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.loc
  *  log uses. `logLine` is expected to go through a `Logger` (so it respects `--log-level`), not a
  *  raw `console.log`. */
 async function runStep(app, item, panelEnabled, cwd, command, logLine) {
+    /** **Set here rather than at each of the three call sites**, which is also what keeps `wipe` out
+     *  of it: a wipe runs no command, and this is the one place a `ci` step has one. */
+    item.currentCommand = command;
     if (panelEnabled) {
         await exec(command, {
             app,

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

@@ -53,6 +53,7 @@ export var CleanService;
         const progress = options.progress ?? true;
         const logger = new Logger(options.logLevel ?? resolveRootLogLevel(repository));
         const panel = new ProgressPanel(dryRun ? 'CLEAN (dry-run)' : 'CLEAN', !!process.stdout.isTTY && progress);
+        panel.detail = repository.name;
         panel.start(repository.app.statusRegion);
         let failed = false;
         try {

package/commands/changelog.command.js

@@ -225,6 +225,7 @@ const changelogCommand = registerCommand(app => {
                 progress: panelReporter(panel),
             };
             const changelog = app.getService('changelog');
+            panel.detail = repository.name;
             panel.start(app.statusRegion);
             let entries;
             try {

package/constants.js

@@ -1 +1 @@
-export const version = '2.6.1';
+export const version = '2.8.0';

package/package.json

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

package/services/exec.service.js

@@ -52,9 +52,14 @@ export class ExecService extends Service {
         const names = new Set(packages.map(p => p.name));
         const children = packages.map(pkg => {
             const ctx = panel.addItem(pkg.name);
+            /** One command for every package and it never changes, so it is set once here rather than
+             *  threaded into `execForPackage` - the row is the only thing that was not saying what `exec`
+             *  is actually running. */
+            ctx.currentCommand = command;
             const dependencies = topo ? pkg.dependencies.filter(d => names.has(d.name)).map(d => d.name) : [];
             return new Task(() => execForPackage(this.app, ctx, panel.enabled, pkg.dirname, command, logger, bail ? () => rootTask?.abort() : () => { }), { name: pkg.name, dependencies });
         });
+        panel.detail = repository.name;
         panel.start(repository.app.statusRegion);
         let failed = false;
         try {

package/services/run.service.d.ts

@@ -168,7 +168,16 @@ export declare namespace RunService {
      * differently, which is how `version.<slot>` came to join its array with `' && '`.
      */
     export function normalizeScriptValue(value: unknown, at: string): RunStepValue[];
-    export function createStepContext(pkg: Package, cwd: string): RunStepContext;
+    /**
+     * Runs `fn` with `console` captured into `onLine`, and leaves the real `console` behind when the
+     * last concurrent step is done.
+     */
+    export function withCapturedConsole<T>(onLine: (line: string) => void, fn: () => T | Promise<T>): Promise<T>;
+    /**
+     * `onCommand` is told what the step is spawning, for as long as it runs - the argv while a child
+     * is up, `undefined` when it returns.
+     */
+    export function createStepContext(pkg: Package, cwd: string, onCommand?: (command: string | undefined) => void, onLine?: (line: string) => void): RunStepContext;
     /**
      * `.rmanrc` conditional execution, GitHub Actions-`if`-flavored but a small closed grammar
      * instead of a full expression language (less to get wrong, still covers what's asked for) -

package/services/run.service.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import os from 'node:os';
 import { inspect } from 'node:util';
 import colors from 'ansi-colors';
@@ -66,7 +67,13 @@ export class RunService extends Service {
                      *  does not distinguish a JS step from a shell one. `step.label` is not used directly
                      *  because for a function it already folds the slot in (`before (js)`), which the row
                      *  prints two characters to its left. */
-                    ctx.currentCommand = step.command ?? (step.run?.name ? `${step.run.name}()` : '(js function)');
+                    const stepLabel = step.command ?? (step.run?.name ? `${step.run.name}()` : '(js function)');
+                    ctx.currentCommand = stepLabel;
+                    /** A function step names itself until it spawns something, and takes its name back when
+                     *  that returns - so the row says `tsc -b tsconfig.json` for as long as tsc is up. */
+                    const onCommand = (command) => {
+                        ctx.currentCommand = command ?? stepLabel;
+                    };
                     ctx.stepIndex = i;
                     if (panel.enabled) {
                         const onLine = (line) => {
@@ -74,7 +81,7 @@ export class RunService extends Service {
                             ctx.lastLine = line;
                         };
                         if (step.run)
-                            await runFunctionStep(step.run, pkg, cwd, onLine);
+                            await runFunctionStep(step.run, pkg, cwd, onLine, onCommand);
                         else
                             await exec(step.command, { cwd, stdio: 'pipe', onLine, app: pkg.repository.app });
                     }
@@ -88,7 +95,7 @@ export class RunService extends Service {
                             /** No capture with the panel off: the step owns the terminal, exactly as a shell
                              *  step's `stdio: 'inherit'` does. */
                             if (step.run)
-                                await runFunctionStep(step.run, pkg, cwd);
+                                await runFunctionStep(step.run, pkg, cwd, undefined, onCommand);
                             else
                                 await exec(step.command, { cwd, stdio: 'inherit', app: pkg.repository.app });
                         }
@@ -228,6 +235,7 @@ export class RunService extends Service {
             err.logged = true;
             throw err;
         }
+        panel.detail = repository.name;
         panel.start(repository.app.statusRegion);
         try {
             /** bail:false here - each package's own resolved bail setting decides whether to call
@@ -361,13 +369,87 @@ export class RunService extends Service {
         return steps;
     }
     RunService.normalizeScriptValue = normalizeScriptValue;
-    function createStepContext(pkg, cwd) {
+    /**
+     * Runs `fn` with `console` captured into `onLine`, and leaves the real `console` behind when the
+     * last concurrent step is done.
+     */
+    /* **One patch for the whole run, routed per step - and the obvious alternative is broken under
+     * concurrency.** Patching per step and restoring "the original" works for one step and corrupts the
+     * console for every run with two:
+     *
+     *     A patches   -> A's "original" is the real console
+     *     B patches   -> B's "original" is *A's patch*
+     *     A restores  -> console is real again
+     *     B restores  -> console is A's patch, for the rest of the process
+     *
+     * Measured on a twenty-package build with sixteen running at once: afterwards `printSummary`'s own
+     * `console.log` calls went into a finished package's log array, so the run printed **no recap and
+     * no failure logs at all** - every error silently swallowed, which is the opposite of what the
+     * capture is for. The depth counter is what restores the pristine console rather than whatever was
+     * installed when this step started.
+     *
+     * `AsyncLocalStorage` is what makes one shared patch route to the right step: the steps interleave
+     * on the event loop, so the call stack cannot say which package a `console.log` belongs to, and
+     * `await` inside an author's function is exactly what it propagates through. A log from outside any
+     * step - a timer a step left running - finds no store and goes to the real console, which is right.
+     */
+    function withCapturedConsole(onLine, fn) {
+        const console_ = globalThis.console;
+        if (consoleDepth++ === 0) {
+            const pristine = {};
+            for (const method of CAPTURED_CONSOLE) {
+                pristine[method] = console_[method];
+                console_[method] = (...args) => {
+                    const sink = consoleSink.getStore();
+                    if (!sink)
+                        return pristine[method](...args);
+                    /** Split, because one `console.log` may carry several lines and the panel's log is a list
+                     *  of them - a multi-line entry would render as one unreadable row. */
+                    for (const line of format(args).split('\n'))
+                        sink(line);
+                };
+            }
+            pristineConsole = pristine;
+        }
+        /** `Promise.resolve`, because a step may be a plain function - `RunStepFn` returns
+         *  `void | Promise<void>` and only the promise form can be awaited. */
+        return Promise.resolve(consoleSink.run(onLine, fn)).finally(() => {
+            if (--consoleDepth > 0 || !pristineConsole)
+                return;
+            for (const method of CAPTURED_CONSOLE)
+                console_[method] = pristineConsole[method];
+            pristineConsole = undefined;
+        });
+    }
+    RunService.withCapturedConsole = withCapturedConsole;
+    /**
+     * `onCommand` is told what the step is spawning, for as long as it runs - the argv while a child
+     * is up, `undefined` when it returns.
+     */
+    /* **Without it a function step can only name itself.** The row showed `buildWithTsc()` for the
+     * whole of a build, because that is all the slot knows; what a reader wants is the `tsc -b
+     * <tsconfig>` it is sitting in. A function step is the shape every shared config uses, so this is
+     * the common case rather than an edge one. */
+    function createStepContext(pkg, cwd, onCommand, onLine) {
         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 }),
+            runBin: async (bin, argv, opts) => {
+                onCommand?.([bin, ...argv].join(' '));
+                const result = await runBin(bin, argv, { cwd, logLevel, app: pkg.repository.app, onLine, ...opts });
+                /**
+                 * **Handed back on success only, so a failure leaves the command that failed on the row.**
+                 */
+                /* A rejection skips this line, which is the whole point: the step is over, its row becomes
+                 * a failed one, and `buildWithTsc()` is a worse thing to read there than the
+                 * `tsc -b <tsconfig>` that actually exited non-zero. On the way out of a *successful* call
+                 * the name does have to come back, or a step that spawns once would wear that command for
+                 * the rest of its run. */
+                onCommand?.(undefined);
+                return result;
+            },
             logger: new Logger(logLevel),
         };
     }
@@ -510,8 +592,8 @@ function toStep(slot, value) {
  * 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);
+async function runFunctionStep(run, pkg, cwd, onLine, onCommand) {
+    const context = RunService.createStepContext(pkg, cwd, onCommand, onLine);
     if (!onLine) {
         try {
             await run(context);
@@ -522,32 +604,21 @@ async function runFunctionStep(run, pkg, cwd, onLine) {
         }
         return;
     }
-    const console_ = globalThis.console;
-    const original = {};
-    for (const method of CAPTURED_CONSOLE) {
-        original[method] = console_[method];
-        console_[method] = (...args) => {
-            /** Split, because one `console.log` may carry several lines and the panel's log is a list of
-             *  them - a multi-line entry would render as one unreadable row. */
-            for (const line of format(args).split('\n'))
-                onLine(line);
-        };
-    }
     try {
-        await run(context);
+        await RunService.withCapturedConsole(onLine, () => 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. */
+        /** Straight to `onLine`, 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];
-    }
 }
+/** Which step a captured `console` call belongs to - see `withCapturedConsole`. */
+const consoleSink = new AsyncLocalStorage();
+let consoleDepth = 0;
+let pristineConsole;
 /** 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) {

package/utils/progress-panel.d.ts

@@ -49,6 +49,12 @@ export declare class ProgressPanel implements TerminalRegion {
     private renderLoop?;
     /** The region this panel took the terminal from, handed back in `stop`. */
     private statusRegion?;
+    /**
+     * What the run is about - the repository name, shown beside the title. Assigned rather than
+     * constructed with, the way a `ProgressItem`'s fields are: it keeps `stream` from needing an
+     * `undefined` placeholder at four of the five call sites.
+     */
+    detail?: string;
     private spinnerFrame;
     private startedAt;
     /**

package/utils/progress-panel.js

@@ -21,6 +21,12 @@ export class ProgressPanel {
     renderLoop;
     /** The region this panel took the terminal from, handed back in `stop`. */
     statusRegion;
+    /**
+     * What the run is about - the repository name, shown beside the title. Assigned rather than
+     * constructed with, the way a `ProgressItem`'s fields are: it keeps `stream` from needing an
+     * `undefined` placeholder at four of the five call sites.
+     */
+    detail;
     spinnerFrame = 0;
     startedAt = 0;
     /**
@@ -39,7 +45,7 @@ export class ProgressPanel {
     /** Registers an item and returns it - callers mutate the returned object directly (`status`,
      *  `currentStep`, `lastLine`, ...) to drive the next render tick. */
     addItem(name, stepsTotal) {
-        const item = { name, status: 'pending', stepsTotal, log: [] };
+        const item = new PanelItem(name, stepsTotal);
         this.items.set(name, item);
         return item;
     }
@@ -111,29 +117,67 @@ export class ProgressPanel {
         const bar = renderProgressBar(filled, total);
         const totalElapsed = formatDuration(Date.now() - this.startedAt);
         const failedText = failedSoFar > 0 ? colors.red.bold(`${failedSoFar} failed`) : colors.gray(`${failedSoFar} failed`);
+        /**
+         * **The header says what is running, because nothing else does any more.** The status line used
+         * to carry `ci opra` beside this panel; it is suspended now so the two stop redrawing over each
+         * other, and suppressing it without moving its content here took the command and the repository
+         * off the screen entirely. The badge already names the command, so what had to move is the
+         * repository.
+         *
+         * **At the right end, where the line has room.** Between the badge and the bar it would push
+         * every column right by the length of a repository name - so the bar, the counts and the clock
+         * would sit at a different place in each repository, and the bar would shift the moment a
+         * panel's detail were set. The tail is empty space in every terminal this fits in.
+         */
+        const detail = this.detail ? `   ${colors.gray(this.detail)}` : '';
         const lines = [
-            `${header} ${bar} ${colors.bold(`${done}/${total}`)}  ${colors.cyan(`${running} running`)}  ${failedText}  ${colors.yellow(totalElapsed)}`,
+            `${header} ${bar} ${colors.bold(`${done}/${total}`)}  ${colors.cyan(`${running} running`)}  ${failedText}  ${colors.yellow(totalElapsed)}${detail}`,
         ];
         const runningList = [...this.items.values()].filter(i => i.status === 'running');
-        /** Leave room for the header, a safety margin, and a possible "N more running" line - a
-         *  block taller than the terminal breaks cursor-up math (the terminal scrolls instead of
-         *  the cursor moving, so redraws land in the wrong place and pile up). */
+        /**
+         * **A package that failed stays on the list, under the ones still working.**
+         * It used to vanish the moment it failed, so on a long run the only sign that anything had gone
+         * wrong was a count in the header - and whatever it printed was not read until the recap, by
+         * which time the run had been going for another half-minute.
+         *
+         * **Below the running rows, and only with the space they leave.** Work in progress is what the
+         * panel is for; a repository that fails early would otherwise fill the block with corpses and
+         * push the live rows off the screen. One line each rather than two, so more of them fit - a
+         * failed row's value is that it is *named*, and its output is replayed in full at the end.
+         */
+        const failedList = [...this.items.values()].filter(i => i.status === 'failed');
+        /** Leave room for the header, a safety margin, and a possible "N more" line - a block taller
+         *  than the terminal breaks cursor-up math (the terminal scrolls instead of the cursor moving,
+         *  so redraws land in the wrong place and pile up). */
         const budget = Math.max(0, (process.stdout.rows || 24) - 3);
+        const width = process.stdout.columns || 80;
         let used = 0;
-        let shown = 0;
-        for (const item of runningList) {
-            const elapsed = item.startedAt ? formatDuration(Date.now() - item.startedAt) : '';
+        let shownRunning = 0;
+        let shownFailed = 0;
+        /** The fixed-width half of a row, plus the command truncated into whatever is left. */
+        const describe = (item, elapsed) => {
             const step = item.stepsTotal && item.stepsTotal > 1 && item.stepIndex != null
                 ? `${item.currentStep} (${item.stepIndex + 1}/${item.stepsTotal})`
                 : item.currentStep || '';
-            /** Measured against the *plain* text: every piece below is wrapped in escape sequences, and
+            /** Measured against the *plain* text: every piece is wrapped in escape sequences, and
              *  `String.length` counts those, so budgeting on the rendered string wraps a row that fits. */
-            const fixed = `  ${item.name}  ${step}  ${elapsed}`.length;
-            const command = truncate(item.currentCommand ?? '', (process.stdout.columns || 80) - fixed - 2);
+            const fixed = `  ${item.name}  ${step}  ${elapsed} | `.length;
+            return { step, command: truncate(item.currentCommand ?? '', width - fixed - 2) };
+        };
+        for (const item of runningList) {
+            const elapsed = item.startedAt ? formatDuration(Date.now() - item.startedAt) : '';
+            const { step, command } = describe(item, elapsed);
+            /**
+             * **The command last, after a `|`, and that is not only layout.** It is the one field with no
+             * bound on its length - a `tsc -b` line carries a path, a `run` step carries whatever the
+             * author wrote - so between the step and the clock it pushed the elapsed time to a different
+             * column on every row, and off the end entirely once a command was long. Everything
+             * fixed-width now reads down a straight edge and the variable part runs off to the right,
+             * where `truncate` cuts it.
+             */
             const group = [
-                `${spinner} ${colors.bold(item.name)}  ${colors.gray(step)}` +
-                    (command ? `  ${colors.cyan(command)}` : '') +
-                    `  ${colors.yellow(elapsed)}`,
+                `${spinner} ${colors.bold(item.name)}  ${colors.gray(step)}  ${colors.yellow(elapsed)}` +
+                    (command ? `  ${colors.gray('|')} ${colors.cyan(command)}` : ''),
             ];
             if (item.lastLine)
                 group.push(`    ${colors.dim(item.lastLine)}`);
@@ -141,11 +185,27 @@ export class ProgressPanel {
                 break;
             lines.push(...group);
             used += group.length;
-            shown++;
+            shownRunning++;
+        }
+        for (const item of failedList) {
+            if (used + 1 > budget)
+                break;
+            const elapsed = item.startedAt && item.finishedAt ? formatDuration(item.finishedAt - item.startedAt) : '';
+            const { step, command } = describe(item, elapsed);
+            lines.push(`${colors.red.bold('✖')} ${colors.bold(item.name)}  ${colors.gray(step)}  ${colors.yellow(elapsed)}` +
+                (command ? `  ${colors.gray('|')} ${colors.red(command)}` : ''));
+            used++;
+            shownFailed++;
         }
-        const remaining = runningList.length - shown;
-        if (remaining > 0)
-            lines.push(colors.gray(`… and ${remaining} more running`));
+        /** One line for both, or a run with rows cut from each would need two and the block is already
+         *  budgeted to the row. */
+        const hidden = [];
+        if (runningList.length > shownRunning)
+            hidden.push(`${runningList.length - shownRunning} more running`);
+        if (failedList.length > shownFailed)
+            hidden.push(`${failedList.length - shownFailed} more failed`);
+        if (hidden.length)
+            lines.push(colors.gray(`… and ${hidden.join(', ')}`));
         this.live.render(lines);
     }
     /** Stops the redraw loop and erases the panel, leaving the cursor where it started. */
@@ -241,3 +301,51 @@ function renderProgressBar(done, total, width = 24) {
     const filled = Math.max(0, Math.min(width, cells));
     return colors.green('█'.repeat(filled)) + colors.gray('░'.repeat(width - filled));
 }
+/**
+ * What `addItem` hands back - a `ProgressItem` whose `currentStep` and `currentCommand` clear
+ * `lastLine` when they change.
+ */
+/* **Accessors rather than a line at each call site**, because the call sites are four services and
+ * a command and the one that forgets is invisible: stale output under a new command does not look
+ * like a bug, it looks like output. Reported from `ci`, where the row read
+ * `install (2/2) | npm install` over `removed node_modules, package-lock.json` - the wipe's line,
+ * sitting under the install's command as though it belonged to it.
+ *
+ * **Cleared where it changes, not at render time.** The panel redraws every 100ms, so comparing
+ * there would race a line that arrived between the change and the next frame and throw away real
+ * output. This is synchronous with the assignment.
+ */
+class PanelItem {
+    name;
+    status = 'pending';
+    stepIndex;
+    stepsTotal;
+    lastLine;
+    startedAt;
+    finishedAt;
+    log = [];
+    _currentStep;
+    _currentCommand;
+    constructor(name, stepsTotal) {
+        this.name = name;
+        this.stepsTotal = stepsTotal;
+    }
+    get currentStep() {
+        return this._currentStep;
+    }
+    set currentStep(value) {
+        if (value === this._currentStep)
+            return;
+        this._currentStep = value;
+        this.lastLine = undefined;
+    }
+    get currentCommand() {
+        return this._currentCommand;
+    }
+    set currentCommand(value) {
+        if (value === this._currentCommand)
+            return;
+        this._currentCommand = value;
+        this.lastLine = undefined;
+    }
+}

package/utils/run-bin.d.ts

@@ -27,6 +27,10 @@ export interface RunBinOptions {
      *   even then. An explicit `stdio` still wins over all of this.
      */
     logLevel?: LogLevel;
+    /**
+     * Called once per line of the child's output **instead of writing it to the terminal**.
+     */
+    onLine?: (line: string) => void;
     env?: Record<string, string | undefined>;
 }
 export interface RunBinResult {

package/utils/run-bin.js

@@ -39,7 +39,11 @@ export async function runBin(bin, argv, options = {}) {
     const region = options.app?.statusRegion?.live ? options.app.statusRegion : undefined;
     /** Below 'info' the output is captured rather than streamed, so a quiet run stays quiet and a
      *  failing one can still say what went wrong. */
-    const stdio = options.stdio ?? (region ? 'pipe' : atLeast('info') ? 'inherit' : 'pipe');
+    /** **`onLine` forces `pipe` the same way a live region does.** Left to the default, a caller at
+     *  `info` would get `inherit` - the child writes straight to the terminal, `child.stdout` is
+     *  null, and the callback is never called at all. An option that silently does nothing is worse
+     *  than one that does not exist. */
+    const stdio = options.stdio ?? (options.onLine || region ? 'pipe' : atLeast('info') ? 'inherit' : 'pipe');
     if (atLeast('verbose'))
         console.log(colors.magenta('verbose'), colors.gray('$'), bin, argv.join(' '));
     const child = spawn(process.platform === 'win32' ? `${bin}.cmd` : bin, argv, {
@@ -74,6 +78,14 @@ export async function runBin(bin, argv, options = {}) {
     const collect = (d) => {
         const text = d.toString();
         output += text;
+        /** A caller taking the lines owns them - it is showing them somewhere of its own, and writing
+         *  them here as well would both double them and scroll whatever it is drawing. */
+        if (options.onLine) {
+            for (const line of text.split(/\r?\n/))
+                if (line)
+                    options.onLine(line);
+            return;
+        }
         if (region && atLeast('info'))
             region.passThrough(text);
     };
@@ -89,7 +101,7 @@ export async function runBin(bin, argv, options = {}) {
             /** Captured output has to be surfaced here or it is lost with the process - the one thing
              *  worse than a noisy failure is a silent one. 'silent' is the caller saying otherwise. */
             /** Already streamed through the region, so printing it again would double it. */
-            if (stdio === 'pipe' && output && logLevel !== 'silent' && !(region && atLeast('info'))) {
+            if (stdio === 'pipe' && output && logLevel !== 'silent' && !options.onLine && !(region && atLeast('info'))) {
                 process.stderr.write(output);
             }
             const err = new Error(`"${bin} ${argv.join(' ')}" exited with code ${code}`);

package/utils/status-region.d.ts

@@ -55,7 +55,15 @@ export declare class StatusRegion implements TerminalRegion {
      * screen. The answer to *which* region is the forwarding above.
      */
     suspend(takeover?: TerminalRegion): void;
-    /** Takes the terminal back and starts drawing again - a no-op when it was never suspended. */
+    /**
+     * Takes the terminal back - a no-op when it was never suspended.
+     *
+     * **The first frame waits for the timer rather than being drawn now**, which `start` does. A
+     * command is usually seconds from finishing when its panel comes down, and drawing immediately
+     * put one spinner frame on screen between the panel's recap and the result line that replaces it
+     * - a single flash, which is the thing this whole mechanism exists to remove. Anything still
+     * working is drawn 80ms later and nobody waits for it.
+     */
     resume(): void;
     /** Writes `text` without corrupting the block: erase, write, redraw underneath. */
     passThrough(text: string): void;

package/utils/status-region.js

@@ -57,12 +57,26 @@ export class StatusRegion {
         this.timer = undefined;
         this.region.clear();
     }
-    /** Takes the terminal back and starts drawing again - a no-op when it was never suspended. */
+    /**
+     * Takes the terminal back - a no-op when it was never suspended.
+     *
+     * **The first frame waits for the timer rather than being drawn now**, which `start` does. A
+     * command is usually seconds from finishing when its panel comes down, and drawing immediately
+     * put one spinner frame on screen between the panel's recap and the result line that replaces it
+     * - a single flash, which is the thing this whole mechanism exists to remove. Anything still
+     * working is drawn 80ms later and nobody waits for it.
+     */
     resume() {
         if (!this.takeover && this.timer)
             return;
         this.takeover = undefined;
-        this.start();
+        if (!this.region.enabled || this.timer)
+            return;
+        this.timer = setInterval(() => {
+            this.frame++;
+            this.draw();
+        }, FRAME_MS);
+        this.timer.unref();
     }
     /** Writes `text` without corrupting the block: erase, write, redraw underneath. */
     passThrough(text) {