concurrently 9.2.1 → 10.0.1

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

@@ -1,42 +1,6 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputHandler = void 0;
-const Rx = __importStar(require("rxjs"));
-const operators_1 = require("rxjs/operators");
-const defaults = __importStar(require("../defaults"));
+import Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as defaults from '../defaults.js';
 /**
  * Sends input from concurrently through to commands.
  *
@@ -46,7 +10,7 @@ const defaults = __importStar(require("../defaults"));
  *
  * If the input doesn't start with a command identifier, it is then always sent to the default target.
  */
-class InputHandler {
+export class InputHandler {
     logger;
     defaultInputTarget;
     inputStream;
@@ -68,12 +32,13 @@ class InputHandler {
             commandsMap.set(command.name, command);
         }
         Rx.fromEvent(inputStream, 'data')
-            .pipe((0, operators_1.map)((data) => String(data)))
+            .pipe(map((data) => String(data)))
             .subscribe((data) => {
-            let command, input;
             const dataParts = data.split(/:(.+)/s);
             let target = dataParts[0];
-            if (dataParts.length > 1 && (command = commandsMap.get(target))) {
+            let command = commandsMap.get(target);
+            let input;
+            if (dataParts.length > 1 && command) {
                 input = dataParts[1];
             }
             else {
@@ -101,4 +66,3 @@ class InputHandler {
         };
     }
 }
-exports.InputHandler = InputHandler;

package/dist/{src → lib}/flow-control/kill-on-signal.d.ts

@@ -1,6 +1,6 @@
-import EventEmitter from 'events';
-import { Command } from '../command';
-import { FlowController } from './flow-controller';
+import EventEmitter from 'node:events';
+import { Command } from '../command.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Watches the main concurrently process for signals and sends the same signal down to each spawned
  * command.

package/dist/{src → lib}/flow-control/kill-on-signal.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KillOnSignal = void 0;
-const operators_1 = require("rxjs/operators");
+import { map } from 'rxjs/operators';
 const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
 /**
  * Watches the main concurrently process for signals and sends the same signal down to each spawned
  * command.
  */
-class KillOnSignal {
+export class KillOnSignal {
     process;
     abortController;
     constructor({ process, abortController, }) {
@@ -24,7 +21,7 @@ class KillOnSignal {
         SIGNALS.forEach((signal) => this.process.on(signal, signalListener));
         return {
             commands: commands.map((command) => {
-                const closeStream = command.close.pipe((0, operators_1.map)((exitInfo) => {
+                const closeStream = command.close.pipe(map((exitInfo) => {
                     const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
                     return { ...exitInfo, exitCode };
                 }));
@@ -44,4 +41,3 @@ class KillOnSignal {
         };
     }
 }
-exports.KillOnSignal = KillOnSignal;

package/dist/{src → lib}/flow-control/kill-others.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 type ProcessCloseCondition = 'failure' | 'success';
 /**
  * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.

package/dist/{src → lib}/flow-control/kill-others.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KillOthers = void 0;
-const operators_1 = require("rxjs/operators");
-const command_1 = require("../command");
-const utils_1 = require("../utils");
+import { filter, map } from 'rxjs/operators';
+import { Command } from '../command.js';
+import { castArray } from '../utils.js';
 /**
  * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.
  */
-class KillOthers {
+export class KillOthers {
     logger;
     abortController;
     conditions;
@@ -16,7 +13,7 @@ class KillOthers {
     constructor({ logger, abortController, conditions, killSignal, timeoutMs, }) {
         this.logger = logger;
         this.abortController = abortController;
-        this.conditions = (0, utils_1.castArray)(conditions);
+        this.conditions = castArray(conditions);
         this.killSignal = killSignal;
         this.timeoutMs = timeoutMs;
     }
@@ -25,10 +22,10 @@ class KillOthers {
         if (!conditions.length) {
             return { commands };
         }
-        const closeStates = commands.map((command) => command.close.pipe((0, operators_1.map)(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), (0, operators_1.filter)((state) => conditions.includes(state))));
+        const closeStates = commands.map((command) => command.close.pipe(map(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), filter((state) => conditions.includes(state))));
         closeStates.forEach((closeState) => closeState.subscribe(() => {
             this.abortController?.abort();
-            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
+            const killableCommands = commands.filter((command) => Command.canKill(command));
             if (killableCommands.length) {
                 this.logger.logGlobalEvent(`Sending ${this.killSignal || 'SIGTERM'} to other processes..`);
                 killableCommands.forEach((command) => command.kill(this.killSignal));
@@ -43,7 +40,7 @@ class KillOthers {
             return;
         }
         setTimeout(() => {
-            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
+            const killableCommands = commands.filter((command) => Command.canKill(command));
             if (killableCommands) {
                 this.logger.logGlobalEvent(`Sending SIGKILL to ${killableCommands.length} processes..`);
                 killableCommands.forEach((command) => command.kill('SIGKILL'));
@@ -51,4 +48,3 @@ class KillOthers {
         }, this.timeoutMs);
     }
 }
-exports.KillOthers = KillOthers;

package/dist/{src → lib}/flow-control/log-error.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';
 /**
  * Logs when commands failed executing, e.g. due to the executable not existing in the system.
  */

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogError = void 0;
 /**
  * Logs when commands failed executing, e.g. due to the executable not existing in the system.
  */
-class LogError {
+export class LogError {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -18,4 +15,3 @@ class LogError {
         return { commands };
     }
 }
-exports.LogError = LogError;

package/dist/{src → lib}/flow-control/log-exit.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';
 /**
  * Logs the exit code/signal of commands.
  */

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogExit = void 0;
 /**
  * Logs the exit code/signal of commands.
  */
-class LogExit {
+export class LogExit {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -16,4 +13,3 @@ class LogExit {
         return { commands };
     }
 }
-exports.LogExit = LogExit;

package/dist/{src → lib}/flow-control/log-output.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';
 /**
  * Logs the stdout and stderr output of commands.
  */

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogOutput = void 0;
 /**
  * Logs the stdout and stderr output of commands.
  */
-class LogOutput {
+export class LogOutput {
     logger;
     constructor({ logger }) {
         this.logger = logger;
@@ -17,4 +14,3 @@ class LogOutput {
         return { commands };
     }
 }
-exports.LogOutput = LogOutput;

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

@@ -1,6 +1,6 @@
-import { CloseEvent, Command } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { CloseEvent, Command } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 type TimingInfo = {
     name: string;
     duration: string;

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

@@ -1,48 +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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogTimings = void 0;
-const assert = __importStar(require("assert"));
-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 {
@@ -57,7 +21,7 @@ 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);
@@ -90,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/{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/{src → lib}/flow-control/output-error-handler.d.ts

@@ -1,6 +1,6 @@
-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).
  */
@@ -13,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/{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/lib/flow-control/restart-process.js

@@ -0,0 +1,61 @@
+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.
+ */
+export class RestartProcess {
+    logger;
+    scheduler;
+    delay;
+    tries;
+    constructor({ delay, tries, logger, scheduler, }) {
+        this.logger = logger;
+        this.delay = delay ?? 0;
+        this.tries = tries != null ? +tries : defaults.restartTries;
+        this.tries = this.tries < 0 ? Infinity : this.tries;
+        this.scheduler = scheduler;
+    }
+    handle(commands) {
+        if (this.tries === 0) {
+            return { commands };
+        }
+        const delayOperator = delayWhen((_, index) => {
+            const { delay } = this;
+            const value = delay === 'exponential' ? 2 ** index * 1000 : delay;
+            return Rx.timer(value, this.scheduler);
+        });
+        commands
+            .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, 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(skip(this.tries), map(() => false), defaultIfEmpty(false))).subscribe((restart) => {
+            const command = commands[index];
+            if (restart) {
+                this.logger.logCommandEvent(`${command.command} restarted`, command);
+                command.start();
+            }
+        }));
+        return {
+            commands: commands.map((command) => {
+                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;
+                }));
+                // Return a proxy so that mutations happen on the original Command object.
+                // If either `Object.assign()` or `Object.create()` were used, it'd be hard to
+                // reflect the mutations on Command objects referenced by previous flow controllers.
+                return new Proxy(command, {
+                    get(target, prop) {
+                        return prop === 'close' ? closeStream : target[prop];
+                    },
+                });
+            }),
+        };
+    }
+}

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[]): {

package/dist/lib/flow-control/teardown.js

@@ -0,0 +1,45 @@
+import Rx from 'rxjs';
+import { getSpawnOpts } from '../spawn.js';
+export class Teardown {
+    logger;
+    spawn;
+    teardown;
+    constructor({ logger, spawn, commands, }) {
+        this.logger = logger;
+        this.spawn = spawn;
+        this.teardown = commands;
+    }
+    handle(commands) {
+        const { logger, teardown, spawn } = this;
+        const onFinish = async () => {
+            if (!teardown.length) {
+                return;
+            }
+            for (const command of teardown) {
+                logger.logGlobalEvent(`Running teardown command "${command}"`);
+                const child = spawn(command, getSpawnOpts({ stdio: 'raw' }));
+                const error = Rx.fromEvent(child, 'error');
+                const close = Rx.fromEvent(child, 'close');
+                try {
+                    const [exitCode, signal] = await Promise.race([
+                        Rx.firstValueFrom(error).then((event) => {
+                            throw event;
+                        }),
+                        Rx.firstValueFrom(close).then((event) => event),
+                    ]);
+                    logger.logGlobalEvent(`Teardown command "${command}" exited with code ${exitCode ?? signal}`);
+                    if (signal === 'SIGINT') {
+                        break;
+                    }
+                }
+                catch (error) {
+                    const errorText = String(error instanceof Error ? error.stack || error : error);
+                    logger.logGlobalEvent(`Teardown command "${command}" errored:`);
+                    logger.logGlobalEvent(errorText);
+                    return Promise.reject(error);
+                }
+            }
+        };
+        return { commands, onFinish };
+    }
+}

package/dist/{src → lib}/index.d.ts

@@ -1,17 +1,17 @@
-import { Readable } from 'stream';
-import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command';
-import { concurrently as createConcurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently';
-import { FlowController } from './flow-control/flow-controller';
-import { InputHandler } from './flow-control/input-handler';
-import { KillOnSignal } from './flow-control/kill-on-signal';
-import { KillOthers, ProcessCloseCondition } from './flow-control/kill-others';
-import { LogError } from './flow-control/log-error';
-import { LogExit } from './flow-control/log-exit';
-import { LogOutput } from './flow-control/log-output';
-import { LogTimings } from './flow-control/log-timings';
-import { RestartDelay, RestartProcess } from './flow-control/restart-process';
-import { Logger } from './logger';
-export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' | 'hide'> & {
+import { Readable } from 'node:stream';
+import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command.js';
+import { concurrently as createConcurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently.js';
+import type { FlowController } from './flow-control/flow-controller.js';
+import { InputHandler } from './flow-control/input-handler.js';
+import { KillOnSignal } from './flow-control/kill-on-signal.js';
+import { KillOthers, ProcessCloseCondition } from './flow-control/kill-others.js';
+import { LogError } from './flow-control/log-error.js';
+import { LogExit } from './flow-control/log-exit.js';
+import { LogOutput } from './flow-control/log-output.js';
+import { LogTimings } from './flow-control/log-timings.js';
+import { RestartDelay, RestartProcess } from './flow-control/restart-process.js';
+import { Logger } from './logger.js';
+export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' | 'hide' | 'spawn'> & {
     /**
      * Which command(s) should have their output hidden.
      */
@@ -54,11 +54,6 @@ export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' |
      * @see RestartProcess
      */
     restartTries?: number;
-    /**
-     * @deprecated Use `killOthersOn` instead.
-     * @see KillOthers
-     */
-    killOthers?: ProcessCloseCondition | ProcessCloseCondition[];
     /**
      * Once the first command exits with one of these statuses, kill other commands.
      * @see KillOthers
@@ -88,8 +83,15 @@ export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' |
      * If not defined, no argument replacing will happen.
      */
     additionalArguments?: string[];
+    /**
+     * Shell executable used to run command strings.
+     * When unset, uses the `npm_config_script_shell` env variable if present. Otherwise, falls back
+     * to `cmd.exe` on Windows, and `/bin/sh` elsewhere.
+     */
+    shell?: string;
 };
 export declare function concurrently(commands: ConcurrentlyCommandInput[], options?: Partial<ConcurrentlyOptions>): ConcurrentlyResult;
+export default concurrently;
 export { ConcurrentlyCommandInput, ConcurrentlyResult, createConcurrently, Logger };
 export { CloseEvent, Command, CommandIdentifier, TimerEvent };
 export { FlowController, InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };