concurrently 9.2.0 → 10.0.0

package/dist/{src → lib}/flow-control/log-timings.js

@@ -1,42 +1,12 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogTimings = void 0;
-const assert = __importStar(require("assert"));
-const lodash_1 = __importDefault(require("lodash"));
-const Rx = __importStar(require("rxjs"));
-const operators_1 = require("rxjs/operators");
-const date_format_1 = require("../date-format");
-const defaults = __importStar(require("../defaults"));
+import assert from 'node:assert';
+import Rx from 'rxjs';
+import { bufferCount, combineLatestWith, take } from 'rxjs/operators';
+import { DateFormatter } from '../date-format.js';
+import * as defaults from '../defaults.js';
 /**
  * Logs timing information about commands as they start/stop and then a summary when all commands finish.
  */
-class LogTimings {
+export class LogTimings {
     static mapCloseEventToTimingInfo({ command, timings, killed, exitCode, }) {
         const readableDurationMs = (timings.endDate.getTime() - timings.startDate.getTime()).toLocaleString();
         return {
@@ -51,15 +21,13 @@ class LogTimings {
     dateFormatter;
     constructor({ logger, timestampFormat = defaults.timestampFormat, }) {
         this.logger = logger;
-        this.dateFormatter = new date_format_1.DateFormatter(timestampFormat);
+        this.dateFormatter = new DateFormatter(timestampFormat);
     }
     printExitInfoTimingTable(exitInfos) {
         assert.ok(this.logger);
-        const exitInfoTable = (0, lodash_1.default)(exitInfos)
-            .sortBy(({ timings }) => timings.durationSeconds)
-            .reverse()
-            .map(LogTimings.mapCloseEventToTimingInfo)
-            .value();
+        const exitInfoTable = exitInfos
+            .sort((a, b) => b.timings.durationSeconds - a.timings.durationSeconds)
+            .map(LogTimings.mapCloseEventToTimingInfo);
         this.logger.logGlobalEvent('Timings:');
         this.logger.logTable(exitInfoTable);
         return exitInfos;
@@ -86,9 +54,8 @@ class LogTimings {
         // overall summary timings
         const closeStreams = commands.map((command) => command.close);
         const finished = new Rx.Subject();
-        const allProcessesClosed = Rx.merge(...closeStreams).pipe((0, operators_1.bufferCount)(closeStreams.length), (0, operators_1.take)(1), (0, operators_1.combineLatestWith)(finished));
+        const allProcessesClosed = Rx.merge(...closeStreams).pipe(bufferCount(closeStreams.length), take(1), combineLatestWith(finished));
         allProcessesClosed.subscribe(([exitInfos]) => this.printExitInfoTimingTable(exitInfos));
         return { commands, onFinish: () => finished.next() };
     }
 }
-exports.LogTimings = LogTimings;

package/dist/lib/flow-control/log-timings.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/flow-control/log-timings.spec.js

@@ -0,0 +1,89 @@
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
+import { DateFormatter } from '../date-format.js';
+import { Logger } from '../logger.js';
+import { LogTimings } from './log-timings.js';
+// shown in timing order
+const startDate0 = new Date();
+const startDate1 = new Date(startDate0.getTime() + 1000);
+const endDate1 = new Date(startDate0.getTime() + 5000);
+const endDate0 = new Date(startDate0.getTime() + 3000);
+const timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
+const getDurationText = (startDate, endDate) => `${(endDate.getTime() - startDate.getTime()).toLocaleString()}ms`;
+const command0DurationTextMs = getDurationText(startDate0, endDate0);
+const command1DurationTextMs = getDurationText(startDate1, endDate1);
+let controller;
+let logger;
+let commands;
+let command0ExitInfo;
+let command1ExitInfo;
+beforeEach(() => {
+    commands = [new FakeCommand('foo', 'command 1', 0), new FakeCommand('bar', 'command 2', 1)];
+    command0ExitInfo = createFakeCloseEvent({
+        command: commands[0],
+        timings: {
+            startDate: startDate0,
+            endDate: endDate0,
+            durationSeconds: endDate0.getTime() - startDate0.getTime(),
+        },
+        index: commands[0].index,
+    });
+    command1ExitInfo = createFakeCloseEvent({
+        command: commands[1],
+        timings: {
+            startDate: startDate1,
+            endDate: endDate1,
+            durationSeconds: endDate1.getTime() - startDate1.getTime(),
+        },
+        index: commands[1].index,
+    });
+    logger = createMockInstance(Logger);
+    controller = new LogTimings({ logger, timestampFormat });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it("does not log timings and doesn't throw if no logger is provided", () => {
+    controller = new LogTimings({});
+    const { onFinish } = controller.handle(commands);
+    commands[0].timer.next({ startDate: startDate0 });
+    commands[1].timer.next({ startDate: startDate1 });
+    commands[1].timer.next({ startDate: startDate1, endDate: endDate1 });
+    commands[0].timer.next({ startDate: startDate0, endDate: endDate0 });
+    onFinish?.();
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(0);
+});
+it('logs the timings at the start and end (ie complete or error) event of each command', () => {
+    const formatter = new DateFormatter(timestampFormat);
+    controller.handle(commands);
+    commands[0].timer.next({ startDate: startDate0 });
+    commands[1].timer.next({ startDate: startDate1 });
+    commands[1].timer.next({ startDate: startDate1, endDate: endDate1 });
+    commands[0].timer.next({ startDate: startDate0, endDate: endDate0 });
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(4);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[0].command} started at ${formatter.format(startDate0)}`, commands[0]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[1].command} started at ${formatter.format(startDate1)}`, commands[1]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[1].command} stopped at ${formatter.format(endDate1)} after ${command1DurationTextMs}`, commands[1]);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[0].command} stopped at ${formatter.format(endDate0)} after ${command0DurationTextMs}`, commands[0]);
+});
+it('does not log timings summary if there was an error', () => {
+    const { onFinish } = controller.handle(commands);
+    commands[0].close.next(command0ExitInfo);
+    commands[1].error.next(undefined);
+    onFinish?.();
+    expect(logger.logTable).toHaveBeenCalledTimes(0);
+});
+it('logs the sorted timings summary when all processes close successfully after onFinish is called', () => {
+    const { onFinish } = controller.handle(commands);
+    commands[0].close.next(command0ExitInfo);
+    commands[1].close.next(command1ExitInfo);
+    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(0);
+    onFinish?.();
+    expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Timings:');
+    // sorted by duration
+    expect(logger.logTable).toHaveBeenCalledExactlyOnceWith([
+        LogTimings.mapCloseEventToTimingInfo(command1ExitInfo),
+        LogTimings.mapCloseEventToTimingInfo(command0ExitInfo),
+    ]);
+});

package/dist/{src → lib}/flow-control/logger-padding.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 export declare class LoggerPadding implements FlowController {
     private readonly logger;
     constructor({ logger }: {

package/dist/{src → lib}/flow-control/logger-padding.js

@@ -1,7 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerPadding = void 0;
-class LoggerPadding {
+import { COLOR_MARKER_RE } from '../logger.js';
+function visibleLength(value) {
+    return value ? value.replace(COLOR_MARKER_RE, '').length : 0;
+}
+export class LoggerPadding {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -11,7 +12,7 @@ class LoggerPadding {
         // Compute the prefix length now, which works for all styles but those with a PID.
         let length = commands.reduce((length, command) => {
             const content = this.logger.getPrefixContent(command);
-            return Math.max(length, content?.value.length || 0);
+            return Math.max(length, visibleLength(content?.value));
         }, 0);
         this.logger.setPrefixLength(length);
         // The length of prefixes is somewhat stable, except for PIDs, which might change when a
@@ -20,7 +21,7 @@ class LoggerPadding {
         const subs = commands.map((command) => command.timer.subscribe((event) => {
             if (!event.endDate) {
                 const content = this.logger.getPrefixContent(command);
-                length = Math.max(length, content?.value.length || 0);
+                length = Math.max(length, visibleLength(content?.value));
                 this.logger.setPrefixLength(length);
             }
         }));
@@ -32,4 +33,3 @@ class LoggerPadding {
         };
     }
 }
-exports.LoggerPadding = LoggerPadding;

package/dist/lib/flow-control/logger-padding.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/flow-control/logger-padding.spec.js

@@ -0,0 +1,60 @@
+import { beforeEach, expect, it } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { LoggerPadding } from './logger-padding.js';
+let logger;
+let controller;
+let commands;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    controller = new LoggerPadding({ logger });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+it('sets the prefix length on handle', () => {
+    controller.handle(commands);
+    expect(logger.setPrefixLength).toHaveBeenCalledTimes(1);
+});
+it('updates the prefix length when commands emit a start timer', () => {
+    controller.handle(commands);
+    commands[0].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
+    commands[1].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledTimes(3);
+});
+it('sets prefix length to the longest prefix of all commands', () => {
+    logger.getPrefixContent
+        .mockReturnValueOnce({ type: 'default', value: 'foobar' })
+        .mockReturnValueOnce({ type: 'default', value: 'baz' });
+    controller.handle(commands);
+    expect(logger.setPrefixLength).toHaveBeenCalledWith(6);
+});
+it('ignores color markers when measuring prefix length', () => {
+    logger.getPrefixContent
+        .mockReturnValueOnce({ type: 'template', value: '{color}foo{/color}' })
+        .mockReturnValueOnce({ type: 'template', value: '{color}abcd{/color}' });
+    controller.handle(commands);
+    expect(logger.setPrefixLength).toHaveBeenCalledWith(4);
+});
+it('does not shorten the prefix length', () => {
+    logger.getPrefixContent
+        .mockReturnValueOnce({ type: 'default', value: '100' })
+        .mockReturnValueOnce({ type: 'default', value: '1' });
+    controller.handle(commands);
+    commands[0].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledWith(3);
+    commands[0].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledWith(3);
+});
+it('unsubscribes from start timers on finish', () => {
+    logger.getPrefixContent.mockReturnValue({ type: 'default', value: '1' });
+    const { onFinish } = controller.handle(commands);
+    commands[0].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
+    onFinish();
+    commands[0].timer.next({ startDate: new Date() });
+    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
+});

package/dist/{src → lib}/flow-control/output-error-handler.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Writable } from 'stream';
-import { Command } from '../command';
-import { FlowController } from './flow-controller';
+import { Writable } from 'node:stream';
+import { Command } from '../command.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Kills processes and aborts further command spawning on output stream error (namely, SIGPIPE).
  */
@@ -15,6 +13,6 @@ export declare class OutputErrorHandler implements FlowController {
     });
     handle(commands: Command[]): {
         commands: Command[];
-        onFinish(): void;
+        onFinish: () => void;
     };
 }

package/dist/{src → lib}/flow-control/output-error-handler.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutputErrorHandler = void 0;
-const observables_1 = require("../observables");
+import { fromSharedEvent } from '../observables.js';
 /**
  * Kills processes and aborts further command spawning on output stream error (namely, SIGPIPE).
  */
-class OutputErrorHandler {
+export class OutputErrorHandler {
     outputStream;
     abortController;
     constructor({ abortController, outputStream, }) {
@@ -13,7 +10,7 @@ class OutputErrorHandler {
         this.outputStream = outputStream;
     }
     handle(commands) {
-        const subscription = (0, observables_1.fromSharedEvent)(this.outputStream, 'error').subscribe(() => {
+        const subscription = fromSharedEvent(this.outputStream, 'error').subscribe(() => {
             commands.forEach((command) => command.kill());
             // Avoid further commands from spawning, e.g. if `RestartProcess` is used.
             this.abortController.abort();
@@ -24,4 +21,3 @@ class OutputErrorHandler {
         };
     }
 }
-exports.OutputErrorHandler = OutputErrorHandler;

package/dist/lib/flow-control/output-error-handler.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/flow-control/output-error-handler.spec.js

@@ -0,0 +1,41 @@
+import { Writable } from 'node:stream';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FakeCommand } from '../__fixtures__/fake-command.js';
+import { OutputErrorHandler } from './output-error-handler.js';
+let controller;
+let outputStream;
+let abortController;
+let commands;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    abortController = new AbortController();
+    outputStream = new Writable();
+    controller = new OutputErrorHandler({ abortController, outputStream });
+});
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+describe('on output stream error', () => {
+    beforeEach(() => {
+        controller.handle(commands);
+        outputStream.emit('error', new Error('test'));
+    });
+    it('kills every command', () => {
+        expect(commands[0].kill).toHaveBeenCalled();
+        expect(commands[1].kill).toHaveBeenCalled();
+    });
+    it('sends abort signal', () => {
+        expect(abortController.signal.aborted).toBe(true);
+    });
+});
+describe('on finish', () => {
+    it('unsubscribes from output stream error', () => {
+        const { onFinish } = controller.handle(commands);
+        onFinish();
+        outputStream.on('error', vi.fn());
+        outputStream.emit('error', new Error('test'));
+        expect(commands[0].kill).not.toHaveBeenCalled();
+        expect(commands[1].kill).not.toHaveBeenCalled();
+        expect(abortController.signal.aborted).toBe(false);
+    });
+});

package/dist/{src → lib}/flow-control/restart-process.d.ts

@@ -1,7 +1,7 @@
-import * as Rx from 'rxjs';
-import { Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import Rx from 'rxjs';
+import { Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 export type RestartDelay = number | 'exponential';
 /**
  * Restarts commands that fail up to a defined number of times.

package/dist/{src → lib}/flow-control/restart-process.js

@@ -1,36 +1,10 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestartProcess = void 0;
-const Rx = __importStar(require("rxjs"));
-const operators_1 = require("rxjs/operators");
-const defaults = __importStar(require("../defaults"));
+import Rx from 'rxjs';
+import { defaultIfEmpty, delayWhen, filter, map, skip, take, takeWhile } from 'rxjs/operators';
+import * as defaults from '../defaults.js';
 /**
  * Restarts commands that fail up to a defined number of times.
  */
-class RestartProcess {
+export class RestartProcess {
     logger;
     scheduler;
     delay;
@@ -46,21 +20,21 @@ class RestartProcess {
         if (this.tries === 0) {
             return { commands };
         }
-        const delayOperator = (0, operators_1.delayWhen)((_, index) => {
+        const delayOperator = delayWhen((_, index) => {
             const { delay } = this;
-            const value = delay === 'exponential' ? Math.pow(2, index) * 1000 : delay;
+            const value = delay === 'exponential' ? 2 ** index * 1000 : delay;
             return Rx.timer(value, this.scheduler);
         });
         commands
-            .map((command) => command.close.pipe((0, operators_1.take)(this.tries), (0, operators_1.takeWhile)(({ exitCode }) => exitCode !== 0)))
+            .map((command) => command.close.pipe(take(this.tries), takeWhile(({ exitCode }) => exitCode !== 0)))
             .forEach((failure, index) => Rx.merge(
         // Delay the emission (so that the restarts happen on time),
         // explicitly telling the subscriber that a restart is needed
-        failure.pipe(delayOperator, (0, operators_1.map)(() => true)), 
+        failure.pipe(delayOperator, map(() => true)), 
         // Skip the first N emissions (as these would be duplicates of the above),
         // meaning it will be empty because of success, or failed all N times,
         // and no more restarts should be attempted.
-        failure.pipe((0, operators_1.skip)(this.tries), (0, operators_1.map)(() => false), (0, operators_1.defaultIfEmpty)(false))).subscribe((restart) => {
+        failure.pipe(skip(this.tries), map(() => false), defaultIfEmpty(false))).subscribe((restart) => {
             const command = commands[index];
             if (restart) {
                 this.logger.logCommandEvent(`${command.command} restarted`, command);
@@ -69,7 +43,7 @@ class RestartProcess {
         }));
         return {
             commands: commands.map((command) => {
-                const closeStream = command.close.pipe((0, operators_1.filter)(({ exitCode }, emission) => {
+                const closeStream = command.close.pipe(filter(({ exitCode }, emission) => {
                     // We let all success codes pass, and failures only after restarting won't happen again
                     return exitCode === 0 || emission >= this.tries;
                 }));
@@ -85,4 +59,3 @@ class RestartProcess {
         };
     }
 }
-exports.RestartProcess = RestartProcess;

package/dist/lib/flow-control/restart-process.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/flow-control/restart-process.spec.js

@@ -0,0 +1,127 @@
+import { VirtualTimeScheduler } from 'rxjs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { RestartProcess } from './restart-process.js';
+let commands;
+let controller;
+let logger;
+let scheduler;
+beforeEach(() => {
+    commands = [new FakeCommand(), new FakeCommand()];
+    logger = createMockInstance(Logger);
+    // Don't use TestScheduler as it's hardcoded to a max number of "frames" (time),
+    // which don't work for some tests in this suite
+    scheduler = new VirtualTimeScheduler();
+    controller = new RestartProcess({
+        logger,
+        scheduler,
+        delay: 100,
+        tries: 2,
+    });
+});
+it('does not restart processes that complete with success', () => {
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    scheduler.flush();
+    expect(commands[0].start).toHaveBeenCalledTimes(0);
+    expect(commands[1].start).toHaveBeenCalledTimes(0);
+});
+it('restarts processes that fail immediately, if no delay was passed', () => {
+    controller = new RestartProcess({ logger, scheduler, tries: 1 });
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    scheduler.flush();
+    expect(scheduler.now()).toBe(0);
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${commands[0].command} restarted`, commands[0]);
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+});
+it('restarts processes that fail after delay ms has passed', () => {
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    scheduler.flush();
+    expect(scheduler.now()).toBe(100);
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${commands[0].command} restarted`, commands[0]);
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+    expect(commands[1].start).not.toHaveBeenCalled();
+});
+it('restarts processes that fail with an exponential back-off', () => {
+    const tries = 4;
+    controller = new RestartProcess({ logger, scheduler, tries, delay: 'exponential' });
+    controller.handle(commands);
+    let time = 0;
+    for (let i = 0; i < tries; i++) {
+        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        scheduler.flush();
+        time += 2 ** i * 1000;
+        expect(scheduler.now()).toBe(time);
+        expect(logger.logCommandEvent).toHaveBeenCalledTimes(i + 1);
+        expect(commands[0].start).toHaveBeenCalledTimes(i + 1);
+    }
+});
+it('restarts processes up to tries', () => {
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 'SIGTERM' }));
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 'SIGTERM' }));
+    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    scheduler.flush();
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[0].command} restarted`, commands[0]);
+    expect(commands[0].start).toHaveBeenCalledTimes(2);
+});
+it('restart processes forever, if tries is negative', () => {
+    controller = new RestartProcess({
+        logger,
+        scheduler,
+        delay: 100,
+        tries: -1,
+    });
+    expect(controller.tries).toBe(Infinity);
+});
+it('restarts processes until they succeed', () => {
+    controller.handle(commands);
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+    scheduler.flush();
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${commands[0].command} restarted`, commands[0]);
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+});
+describe('returned commands', () => {
+    it('are the same if 0 tries are to be attempted', () => {
+        controller = new RestartProcess({ logger, scheduler });
+        expect(controller.handle(commands)).toMatchObject({ commands });
+    });
+    it('are not the same, but with same length if 1+ tries are to be attempted', () => {
+        const { commands: newCommands } = controller.handle(commands);
+        expect(newCommands).not.toBe(commands);
+        expect(newCommands).toHaveLength(commands.length);
+    });
+    it('skip close events followed by restarts', () => {
+        const { commands: newCommands } = controller.handle(commands);
+        const callback = vi.fn();
+        newCommands[0].close.subscribe(callback);
+        newCommands[1].close.subscribe(callback);
+        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        commands[1].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
+        scheduler.flush();
+        // 1 failure from commands[0], 1 success from commands[1]
+        expect(callback).toHaveBeenCalledTimes(2);
+    });
+    it('keep non-close streams from original commands', () => {
+        const { commands: newCommands } = controller.handle(commands);
+        newCommands.forEach((newCommand, i) => {
+            expect(newCommand.close).not.toBe(commands[i].close);
+            expect(newCommand.error).toBe(commands[i].error);
+            expect(newCommand.stdout).toBe(commands[i].stdout);
+            expect(newCommand.stderr).toBe(commands[i].stderr);
+        });
+    });
+});

package/dist/{src → lib}/flow-control/teardown.d.ts

@@ -1,6 +1,6 @@
-import { Command, SpawnCommand } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Command, SpawnCommand } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 export declare class Teardown implements FlowController {
     private readonly logger;
     private readonly spawn;
@@ -9,9 +9,8 @@ export declare class Teardown implements FlowController {
         logger: Logger;
         /**
          * Which function to use to spawn commands.
-         * Defaults to the same used by the rest of concurrently.
          */
-        spawn?: SpawnCommand;
+        spawn: SpawnCommand;
         commands: readonly string[];
     });
     handle(commands: Command[]): {