@node-core/utils 7.1.0 → 7.2.1

package/node_modules/listr2/dist/{index.js → index.mjs}

@@ -1,10 +1,9 @@
-import EventEmitter from "eventemitter3";
-import { createColors } from "colorette";
+import EventEmitter, { setMaxListeners } from "node:events";
+import { inspect, styleText } from "node:util";
 import { format } from "util";
 import { EOL } from "os";
 import { StringDecoder } from "string_decoder";
 import { Writable } from "stream";
-import rfdc from "rfdc";
 import { randomUUID } from "crypto";
 
 //#region src/constants/ansi-escape-codes.constants.ts
@@ -16,8 +15,8 @@ const ANSI_ESCAPE = "\x1B[";
 * Generic ANSI escape characters for terminal based operations.
 */
 const ANSI_ESCAPE_CODES = {
-	CURSOR_HIDE: ANSI_ESCAPE + "?25l",
-	CURSOR_SHOW: ANSI_ESCAPE + "?25h"
+	CURSOR_HIDE: "\x1B[?25l",
+	CURSOR_SHOW: "\x1B[?25h"
 };
 
 //#endregion
@@ -25,12 +24,12 @@ const ANSI_ESCAPE_CODES = {
 /**
 * Environment variables for Listr.
 */
-let ListrEnvironmentVariables = /* @__PURE__ */ function(ListrEnvironmentVariables$1) {
-	ListrEnvironmentVariables$1["FORCE_UNICODE"] = "LISTR_FORCE_UNICODE";
-	ListrEnvironmentVariables$1["FORCE_TTY"] = "LISTR_FORCE_TTY";
-	ListrEnvironmentVariables$1["DISABLE_COLOR"] = "NO_COLOR";
-	ListrEnvironmentVariables$1["FORCE_COLOR"] = "FORCE_COLOR";
-	return ListrEnvironmentVariables$1;
+let ListrEnvironmentVariables = /* @__PURE__ */ function(ListrEnvironmentVariables) {
+	ListrEnvironmentVariables["FORCE_UNICODE"] = "LISTR_FORCE_UNICODE";
+	ListrEnvironmentVariables["FORCE_TTY"] = "LISTR_FORCE_TTY";
+	ListrEnvironmentVariables["DISABLE_COLOR"] = "NO_COLOR";
+	ListrEnvironmentVariables["FORCE_COLOR"] = "FORCE_COLOR";
+	return ListrEnvironmentVariables;
 }({});
 
 //#endregion
@@ -38,18 +37,18 @@ let ListrEnvironmentVariables = /* @__PURE__ */ function(ListrEnvironmentVariabl
 /**
 * The actual error type that is collected and to help identify where the error is triggered from.
 */
-let ListrErrorTypes = /* @__PURE__ */ function(ListrErrorTypes$1) {
+let ListrErrorTypes = /* @__PURE__ */ function(ListrErrorTypes) {
 	/** Task has failed and will try to retry. */
-	ListrErrorTypes$1["WILL_RETRY"] = "WILL_RETRY";
+	ListrErrorTypes["WILL_RETRY"] = "WILL_RETRY";
 	/** Task has failed and will try to rollback. */
-	ListrErrorTypes$1["WILL_ROLLBACK"] = "WILL_ROLLBACK";
+	ListrErrorTypes["WILL_ROLLBACK"] = "WILL_ROLLBACK";
 	/** Task has failed, ran the rollback action but the rollback action itself has failed. */
-	ListrErrorTypes$1["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
+	ListrErrorTypes["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
 	/** Task has failed. */
-	ListrErrorTypes$1["HAS_FAILED"] = "HAS_FAILED";
+	ListrErrorTypes["HAS_FAILED"] = "HAS_FAILED";
 	/** Task has failed, but exitOnError is set to false, so will ignore this error. */
-	ListrErrorTypes$1["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
-	return ListrErrorTypes$1;
+	ListrErrorTypes["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
+	return ListrErrorTypes;
 }({});
 
 //#endregion
@@ -61,19 +60,19 @@ let ListrErrorTypes = /* @__PURE__ */ function(ListrErrorTypes$1) {
 *
 * @see {@link https://listr2.kilic.dev/listr/events.html}
 */
-let ListrEventType = /* @__PURE__ */ function(ListrEventType$1) {
+let ListrEventType = /* @__PURE__ */ function(ListrEventType) {
 	/** Indicates that underlying renderer should refresh the current render. */
-	ListrEventType$1["SHOULD_REFRESH_RENDER"] = "SHOUD_REFRESH_RENDER";
-	return ListrEventType$1;
+	ListrEventType["SHOULD_REFRESH_RENDER"] = "SHOUD_REFRESH_RENDER";
+	return ListrEventType;
 }({});
 
 //#endregion
 //#region src/constants/listr-renderer.constants.ts
-let ListrRendererSelection = /* @__PURE__ */ function(ListrRendererSelection$1) {
-	ListrRendererSelection$1["PRIMARY"] = "PRIMARY";
-	ListrRendererSelection$1["SECONDARY"] = "SECONDARY";
-	ListrRendererSelection$1["SILENT"] = "SILENT";
-	return ListrRendererSelection$1;
+let ListrRendererSelection = /* @__PURE__ */ function(ListrRendererSelection) {
+	ListrRendererSelection["PRIMARY"] = "PRIMARY";
+	ListrRendererSelection["SECONDARY"] = "SECONDARY";
+	ListrRendererSelection["SILENT"] = "SILENT";
+	return ListrRendererSelection;
 }({});
 
 //#endregion
@@ -83,32 +82,34 @@ let ListrRendererSelection = /* @__PURE__ */ function(ListrRendererSelection$1)
 *
 * @see {@link https://listr2.kilic.dev/task/events.html}
 */
-let ListrTaskEventType = /* @__PURE__ */ function(ListrTaskEventType$1) {
+let ListrTaskEventType = /* @__PURE__ */ function(ListrTaskEventType) {
 	/** Title has changed for the current Task. */
-	ListrTaskEventType$1["TITLE"] = "TITLE";
+	ListrTaskEventType["TITLE"] = "TITLE";
 	/**
 	* State has changed for the current Task.
 	*
 	* @see {@link module:listr2.ListrTaskState}
 	*/
-	ListrTaskEventType$1["STATE"] = "STATE";
+	ListrTaskEventType["STATE"] = "STATE";
 	/** The current Task has been marked as enabled. */
-	ListrTaskEventType$1["ENABLED"] = "ENABLED";
+	ListrTaskEventType["ENABLED"] = "ENABLED";
 	/** The current Task is currently processing subtasks. */
-	ListrTaskEventType$1["SUBTASK"] = "SUBTASK";
+	ListrTaskEventType["SUBTASK"] = "SUBTASK";
 	/** The current Task is now processing a prompt. */
-	ListrTaskEventType$1["PROMPT"] = "PROMPT";
+	ListrTaskEventType["PROMPT"] = "PROMPT";
 	/** The current Task is now dumping output. */
-	ListrTaskEventType$1["OUTPUT"] = "OUTPUT";
+	ListrTaskEventType["OUTPUT"] = "OUTPUT";
+	/** The current Task has reset its streamed output. */
+	ListrTaskEventType["OUTPUT_RESET"] = "OUTPUT_RESET";
 	/**
 	* The current Task is now dumping a message.
 	*
 	* @see {module:Listr2.ListrTaskMessage}
 	*/
-	ListrTaskEventType$1["MESSAGE"] = "MESSAGE";
+	ListrTaskEventType["MESSAGE"] = "MESSAGE";
 	/** The current Task is closed and no further action in expected. */
-	ListrTaskEventType$1["CLOSED"] = "CLOSED";
-	return ListrTaskEventType$1;
+	ListrTaskEventType["CLOSED"] = "CLOSED";
+	return ListrTaskEventType;
 }({});
 
 //#endregion
@@ -118,49 +119,57 @@ let ListrTaskEventType = /* @__PURE__ */ function(ListrTaskEventType$1) {
 *
 * Whenever a state change occurs, the task will emit a {@link module:listr2.ListrTaskEventType.STATE} with the appropriate state.
 */
-let ListrTaskState = /* @__PURE__ */ function(ListrTaskState$1) {
+let ListrTaskState = /* @__PURE__ */ function(ListrTaskState) {
 	/** Task has not started yet, waiting for pick-up. */
-	ListrTaskState$1["WAITING"] = "WAITING";
+	ListrTaskState["WAITING"] = "WAITING";
 	/** Task has started. */
-	ListrTaskState$1["STARTED"] = "STARTED";
+	ListrTaskState["STARTED"] = "STARTED";
 	/** Task has been completed. */
-	ListrTaskState$1["COMPLETED"] = "COMPLETED";
+	ListrTaskState["COMPLETED"] = "COMPLETED";
 	/** Task has failed. */
-	ListrTaskState$1["FAILED"] = "FAILED";
+	ListrTaskState["FAILED"] = "FAILED";
 	/** Task has been skipped. */
-	ListrTaskState$1["SKIPPED"] = "SKIPPED";
+	ListrTaskState["SKIPPED"] = "SKIPPED";
 	/** Task is currently trying to rollback. */
-	ListrTaskState$1["ROLLING_BACK"] = "ROLLING_BACK";
+	ListrTaskState["ROLLING_BACK"] = "ROLLING_BACK";
 	/** Task has rolledback successfully after failing. */
-	ListrTaskState$1["ROLLED_BACK"] = "ROLLED_BACK";
+	ListrTaskState["ROLLED_BACK"] = "ROLLED_BACK";
 	/** Task is currently retrying. */
-	ListrTaskState$1["RETRY"] = "RETRY";
+	ListrTaskState["RETRY"] = "RETRY";
 	/** Task is currently paused. */
-	ListrTaskState$1["PAUSED"] = "PAUSED";
+	ListrTaskState["PAUSED"] = "PAUSED";
 	/** Task is currently trying to process a prompt. */
-	ListrTaskState$1["PROMPT"] = "PROMPT";
+	ListrTaskState["PROMPT"] = "PROMPT";
 	/** Task has successfully processed the prompt. */
-	ListrTaskState$1["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
+	ListrTaskState["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
 	/** Task has failed to process the prompt. */
-	ListrTaskState$1["PROMPT_FAILED"] = "PROMPT_FAILED";
-	return ListrTaskState$1;
+	ListrTaskState["PROMPT_FAILED"] = "PROMPT_FAILED";
+	/** Task has been cancelled by an interruption before it could finish. */
+	ListrTaskState["CANCELLED"] = "CANCELLED";
+	return ListrTaskState;
 }({});
 
 //#endregion
 //#region src/lib/event-manager.ts
 var EventManager = class {
 	emitter = new EventEmitter();
+	constructor() {
+		this.emitter.setMaxListeners(0);
+	}
 	emit(dispatch, args) {
 		this.emitter.emit(dispatch, args);
 	}
 	on(dispatch, handler) {
+		if (!handler) return;
 		this.emitter.addListener(dispatch, handler);
 	}
 	once(dispatch, handler) {
+		if (!handler) return;
 		this.emitter.once(dispatch, handler);
 	}
 	off(dispatch, handler) {
-		this.emitter.off(dispatch, handler);
+		if (handler) this.emitter.off(dispatch, handler);
+		else this.emitter.removeAllListeners(dispatch);
 	}
 	complete() {
 		this.emitter.removeAllListeners();
@@ -175,6 +184,45 @@ var EventManager = class {
 */
 var BaseEventMap = class {};
 
+//#endregion
+//#region src/interfaces/listr-error.interface.ts
+/**
+* Internal error handling mechanism for Listr collects the errors and details for a failed task.
+*
+* @see {@link https://listr2.kilic.dev/task/error-handling.html}
+*/
+var ListrError = class extends Error {
+	error;
+	type;
+	task;
+	path;
+	constructor(error, type, task) {
+		super(error.message);
+		this.error = error;
+		this.type = type;
+		this.task = task;
+		this.name = "ListrError";
+		this.path = task.path;
+		this.stack = error?.stack;
+	}
+};
+
+//#endregion
+//#region src/interfaces/listr-renderer-error.interface.ts
+/**
+* Internal error coming from renderer.
+*/
+var ListrRendererError = class extends Error {};
+
+//#endregion
+//#region src/interfaces/prompt-error.interface.ts
+/**
+* Internal error handling mechanism for Listr prompts to identify the failing cause is coming from a prompt.
+*
+* @see {@link https://listr2.kilic.dev/task/prompts.html}
+*/
+var PromptError = class extends Error {};
+
 //#endregion
 //#region src/utils/environment/is-observable.ts
 /**
@@ -199,28 +247,25 @@ function isReadable(obj) {
 //#region src/utils/environment/is-unicode-supported.ts
 function isUnicodeSupported() {
 	/* istanbul ignore next */
-	return !!process.env[ListrEnvironmentVariables.FORCE_UNICODE] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+	return !!process.env["LISTR_FORCE_UNICODE"] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
 }
 
 //#endregion
 //#region src/utils/format/cleanse-ansi.constants.ts
 const CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
-const BELL_REGEX = /\u0007/;
 
 //#endregion
 //#region src/utils/format/cleanse-ansi.ts
 function cleanseAnsi(chunk) {
-	return String(chunk).replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").replace(new RegExp(BELL_REGEX, "gmi"), "").trim();
+	return String(chunk).replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").trim();
 }
 
 //#endregion
 //#region src/utils/format/color.ts
 /**
-* Creates color palette through underlying dependency of `colorette`.
-*
-* @see {@link https://www.npmjs.com/package/colorette}
+* Color palette.
 */
-const color = createColors();
+const color = Object.fromEntries(Object.keys(inspect.colors).map((color) => [color, (text) => styleText(color, String(text))]));
 
 //#endregion
 //#region src/utils/format/indent.ts
@@ -232,6 +277,7 @@ function indent(string, count) {
 //#region src/utils/format/figures.ts
 const FIGURES_MAIN = {
 	warning: "⚠",
+	info: "ℹ",
 	cross: "✖",
 	arrowDown: "↓",
 	tick: "✔",
@@ -240,67 +286,73 @@ const FIGURES_MAIN = {
 	checkboxOn: "☒",
 	arrowLeft: "←",
 	squareSmallFilled: "◼",
-	pointerSmall: "›"
+	pointerSmall: "›",
+	circleSlash: "⊘"
 };
 const FIGURES_FALLBACK = {
 	...FIGURES_MAIN,
 	warning: "‼",
+	info: "i",
 	cross: "×",
 	tick: "√",
 	pointer: ">",
 	checkboxOn: "[×]",
-	squareSmallFilled: "■"
+	squareSmallFilled: "■",
+	circleSlash: "ø"
 };
 const figures = isUnicodeSupported() ? FIGURES_MAIN : FIGURES_FALLBACK;
 
 //#endregion
 //#region src/utils/format/splat.ts
-function splat(message, ...splat$1) {
-	return format(String(message), ...splat$1);
+function splat(message, ...splat) {
+	return format(String(message), ...splat);
 }
 
 //#endregion
 //#region src/utils/logger/logger.constants.ts
 /** Default ListrLogLevels for the logger */
-let ListrLogLevels = /* @__PURE__ */ function(ListrLogLevels$1) {
-	ListrLogLevels$1["STARTED"] = "STARTED";
-	ListrLogLevels$1["COMPLETED"] = "COMPLETED";
-	ListrLogLevels$1["FAILED"] = "FAILED";
-	ListrLogLevels$1["SKIPPED"] = "SKIPPED";
-	ListrLogLevels$1["OUTPUT"] = "OUTPUT";
-	ListrLogLevels$1["TITLE"] = "TITLE";
-	ListrLogLevels$1["ROLLBACK"] = "ROLLBACK";
-	ListrLogLevels$1["RETRY"] = "RETRY";
-	ListrLogLevels$1["PROMPT"] = "PROMPT";
-	ListrLogLevels$1["PAUSED"] = "PAUSED";
-	return ListrLogLevels$1;
+let ListrLogLevels = /* @__PURE__ */ function(ListrLogLevels) {
+	ListrLogLevels["STARTED"] = "STARTED";
+	ListrLogLevels["COMPLETED"] = "COMPLETED";
+	ListrLogLevels["FAILED"] = "FAILED";
+	ListrLogLevels["SKIPPED"] = "SKIPPED";
+	ListrLogLevels["OUTPUT"] = "OUTPUT";
+	ListrLogLevels["TITLE"] = "TITLE";
+	ListrLogLevels["ROLLBACK"] = "ROLLBACK";
+	ListrLogLevels["RETRY"] = "RETRY";
+	ListrLogLevels["PROMPT"] = "PROMPT";
+	ListrLogLevels["PAUSED"] = "PAUSED";
+	ListrLogLevels["CANCELLED"] = "CANCELLED";
+	return ListrLogLevels;
 }({});
 const LISTR_LOGGER_STYLE = {
 	icon: {
-		[ListrLogLevels.STARTED]: figures.pointer,
-		[ListrLogLevels.FAILED]: figures.cross,
-		[ListrLogLevels.SKIPPED]: figures.arrowDown,
-		[ListrLogLevels.COMPLETED]: figures.tick,
-		[ListrLogLevels.OUTPUT]: figures.pointerSmall,
-		[ListrLogLevels.TITLE]: figures.arrowRight,
-		[ListrLogLevels.RETRY]: figures.warning,
-		[ListrLogLevels.ROLLBACK]: figures.arrowLeft,
-		[ListrLogLevels.PAUSED]: figures.squareSmallFilled
+		["STARTED"]: figures.pointer,
+		["FAILED"]: figures.cross,
+		["SKIPPED"]: figures.arrowDown,
+		["COMPLETED"]: figures.tick,
+		["OUTPUT"]: figures.pointerSmall,
+		["TITLE"]: figures.arrowRight,
+		["RETRY"]: figures.warning,
+		["ROLLBACK"]: figures.arrowLeft,
+		["PAUSED"]: figures.squareSmallFilled,
+		["CANCELLED"]: figures.circleSlash
 	},
 	color: {
-		[ListrLogLevels.STARTED]: color.yellow,
-		[ListrLogLevels.FAILED]: color.red,
-		[ListrLogLevels.SKIPPED]: color.yellow,
-		[ListrLogLevels.COMPLETED]: color.green,
-		[ListrLogLevels.RETRY]: color.yellowBright,
-		[ListrLogLevels.ROLLBACK]: color.redBright,
-		[ListrLogLevels.PAUSED]: color.yellowBright
+		["STARTED"]: color.yellow,
+		["FAILED"]: color.red,
+		["SKIPPED"]: color.yellow,
+		["COMPLETED"]: color.green,
+		["RETRY"]: color.yellowBright,
+		["ROLLBACK"]: color.redBright,
+		["PAUSED"]: color.yellowBright,
+		["CANCELLED"]: color.red
 	}
 };
 const LISTR_LOGGER_STDERR_LEVELS = [
-	ListrLogLevels.RETRY,
-	ListrLogLevels.ROLLBACK,
-	ListrLogLevels.FAILED
+	"RETRY",
+	"ROLLBACK",
+	"FAILED"
 ];
 
 //#endregion
@@ -313,6 +365,7 @@ const LISTR_LOGGER_STDERR_LEVELS = [
 * @see {@link https://listr2.kilic.dev/renderer/logger.html}
 */
 var ListrLogger = class {
+	options;
 	process;
 	constructor(options) {
 		this.options = options;
@@ -417,6 +470,7 @@ var ListrLogger = class {
 //#endregion
 //#region src/utils/process-output/process-output-buffer.ts
 var ProcessOutputBuffer = class {
+	options;
 	buffer = [];
 	decoder = new StringDecoder();
 	constructor(options) {
@@ -450,6 +504,7 @@ var ProcessOutputBuffer = class {
 //#endregion
 //#region src/utils/process-output/process-output-stream.ts
 var ProcessOutputStream = class {
+	stream;
 	method;
 	buffer;
 	constructor(stream) {
@@ -458,7 +513,11 @@ var ProcessOutputStream = class {
 		this.buffer = new ProcessOutputBuffer({ stream });
 	}
 	get out() {
-		return Object.assign({}, this.stream, { write: this.write.bind(this) });
+		const self = this;
+		return new Proxy(this.stream, { get(target, prop, receiver) {
+			if (prop === "write") return self.write.bind(self);
+			return Reflect.get(target, prop, receiver);
+		} });
 	}
 	hijack() {
 		this.stream.write = this.buffer.write.bind(this.buffer);
@@ -484,6 +543,7 @@ var ProcessOutputStream = class {
 * @see {@link https://listr2.kilic.dev/renderer/process-output.html}
 */
 var ProcessOutput = class {
+	options;
 	stream;
 	active;
 	constructor(stdout, stderr, options) {
@@ -514,7 +574,7 @@ var ProcessOutput = class {
 		const output = Object.entries(this.stream).map(([name, stream]) => ({
 			name,
 			buffer: stream.release()
-		})).filter((output$1) => this.options.dump.includes(output$1.name)).flatMap((output$1) => output$1.buffer).sort((a, b) => a.time - b.time).map((message) => {
+		})).filter((output) => this.options.dump.includes(output.name)).flatMap((output) => output.buffer).sort((a, b) => a.time - b.time).map((message) => {
 			return {
 				...message,
 				entry: cleanseAnsi(message.entry)
@@ -557,6 +617,8 @@ function createWritable(cb) {
 //#region src/utils/prompts/adapter.ts
 /* istanbul ignore next */
 var ListrPromptAdapter = class {
+	task;
+	wrapper;
 	state;
 	constructor(task, wrapper) {
 		this.task = task;
@@ -566,14 +628,14 @@ var ListrPromptAdapter = class {
 		this.state = this.task.state;
 		if (this.task.prompt) throw new PromptError("There is already an active prompt attached to this task which may not be cleaned up properly.");
 		this.task.prompt = this;
-		this.task.state$ = ListrTaskState.PROMPT;
+		this.task.state$ = "PROMPT";
 	}
 	reportFailed() {
-		this.task.state$ = ListrTaskState.PROMPT_FAILED;
+		this.task.state$ = "PROMPT_FAILED";
 		this.restoreState();
 	}
 	reportCompleted() {
-		this.task.state$ = ListrTaskState.PROMPT_COMPLETED;
+		this.task.state$ = "PROMPT_COMPLETED";
 		this.restoreState();
 	}
 	restoreState() {
@@ -622,61 +684,65 @@ var Spinner = class {
 	}
 	stop() {
 		clearInterval(this.id);
+		this.id = void 0;
 	}
 };
 
 //#endregion
 //#region src/renderer/default/renderer.constants.ts
-let ListrDefaultRendererLogLevels = /* @__PURE__ */ function(ListrDefaultRendererLogLevels$1) {
-	ListrDefaultRendererLogLevels$1["SKIPPED_WITH_COLLAPSE"] = "SKIPPED_WITH_COLLAPSE";
-	ListrDefaultRendererLogLevels$1["SKIPPED_WITHOUT_COLLAPSE"] = "SKIPPED_WITHOUT_COLLAPSE";
-	ListrDefaultRendererLogLevels$1["OUTPUT"] = "OUTPUT";
-	ListrDefaultRendererLogLevels$1["OUTPUT_WITH_BOTTOMBAR"] = "OUTPUT_WITH_BOTTOMBAR";
-	ListrDefaultRendererLogLevels$1["PENDING"] = "PENDING";
-	ListrDefaultRendererLogLevels$1["COMPLETED"] = "COMPLETED";
-	ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SUBTASKS"] = "COMPLETED_WITH_FAILED_SUBTASKS";
-	ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SISTER_TASKS"] = "COMPLETED_WITH_SISTER_TASKS_FAILED";
-	ListrDefaultRendererLogLevels$1["RETRY"] = "RETRY";
-	ListrDefaultRendererLogLevels$1["ROLLING_BACK"] = "ROLLING_BACK";
-	ListrDefaultRendererLogLevels$1["ROLLED_BACK"] = "ROLLED_BACK";
-	ListrDefaultRendererLogLevels$1["FAILED"] = "FAILED";
-	ListrDefaultRendererLogLevels$1["FAILED_WITH_FAILED_SUBTASKS"] = "FAILED_WITH_SUBTASKS";
-	ListrDefaultRendererLogLevels$1["WAITING"] = "WAITING";
-	ListrDefaultRendererLogLevels$1["PAUSED"] = "PAUSED";
-	return ListrDefaultRendererLogLevels$1;
+let ListrDefaultRendererLogLevels = /* @__PURE__ */ function(ListrDefaultRendererLogLevels) {
+	ListrDefaultRendererLogLevels["SKIPPED_WITH_COLLAPSE"] = "SKIPPED_WITH_COLLAPSE";
+	ListrDefaultRendererLogLevels["SKIPPED_WITHOUT_COLLAPSE"] = "SKIPPED_WITHOUT_COLLAPSE";
+	ListrDefaultRendererLogLevels["OUTPUT"] = "OUTPUT";
+	ListrDefaultRendererLogLevels["OUTPUT_WITH_BOTTOMBAR"] = "OUTPUT_WITH_BOTTOMBAR";
+	ListrDefaultRendererLogLevels["PENDING"] = "PENDING";
+	ListrDefaultRendererLogLevels["COMPLETED"] = "COMPLETED";
+	ListrDefaultRendererLogLevels["COMPLETED_WITH_FAILED_SUBTASKS"] = "COMPLETED_WITH_FAILED_SUBTASKS";
+	ListrDefaultRendererLogLevels["COMPLETED_WITH_FAILED_SISTER_TASKS"] = "COMPLETED_WITH_SISTER_TASKS_FAILED";
+	ListrDefaultRendererLogLevels["RETRY"] = "RETRY";
+	ListrDefaultRendererLogLevels["ROLLING_BACK"] = "ROLLING_BACK";
+	ListrDefaultRendererLogLevels["ROLLED_BACK"] = "ROLLED_BACK";
+	ListrDefaultRendererLogLevels["FAILED"] = "FAILED";
+	ListrDefaultRendererLogLevels["FAILED_WITH_FAILED_SUBTASKS"] = "FAILED_WITH_SUBTASKS";
+	ListrDefaultRendererLogLevels["WAITING"] = "WAITING";
+	ListrDefaultRendererLogLevels["PAUSED"] = "PAUSED";
+	ListrDefaultRendererLogLevels["CANCELLED"] = "CANCELLED";
+	return ListrDefaultRendererLogLevels;
 }({});
 const LISTR_DEFAULT_RENDERER_STYLE = {
 	icon: {
-		[ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE]: figures.arrowDown,
-		[ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE]: figures.warning,
-		[ListrDefaultRendererLogLevels.OUTPUT]: figures.pointerSmall,
-		[ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR]: figures.pointerSmall,
-		[ListrDefaultRendererLogLevels.PENDING]: figures.pointer,
-		[ListrDefaultRendererLogLevels.COMPLETED]: figures.tick,
-		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: figures.warning,
-		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS]: figures.squareSmallFilled,
-		[ListrDefaultRendererLogLevels.RETRY]: figures.warning,
-		[ListrDefaultRendererLogLevels.ROLLING_BACK]: figures.warning,
-		[ListrDefaultRendererLogLevels.ROLLED_BACK]: figures.arrowLeft,
-		[ListrDefaultRendererLogLevels.FAILED]: figures.cross,
-		[ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS]: figures.pointer,
-		[ListrDefaultRendererLogLevels.WAITING]: figures.squareSmallFilled,
-		[ListrDefaultRendererLogLevels.PAUSED]: figures.squareSmallFilled
+		["SKIPPED_WITH_COLLAPSE"]: figures.arrowDown,
+		["SKIPPED_WITHOUT_COLLAPSE"]: figures.warning,
+		["OUTPUT"]: figures.pointerSmall,
+		["OUTPUT_WITH_BOTTOMBAR"]: figures.pointerSmall,
+		["PENDING"]: figures.pointer,
+		["COMPLETED"]: figures.tick,
+		["COMPLETED_WITH_FAILED_SUBTASKS"]: figures.warning,
+		["COMPLETED_WITH_SISTER_TASKS_FAILED"]: figures.squareSmallFilled,
+		["RETRY"]: figures.warning,
+		["ROLLING_BACK"]: figures.warning,
+		["ROLLED_BACK"]: figures.arrowLeft,
+		["FAILED"]: figures.cross,
+		["FAILED_WITH_SUBTASKS"]: figures.pointer,
+		["WAITING"]: figures.squareSmallFilled,
+		["PAUSED"]: figures.squareSmallFilled,
+		["CANCELLED"]: figures.circleSlash
 	},
 	color: {
-		[ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE]: color.yellow,
-		[ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE]: color.yellow,
-		[ListrDefaultRendererLogLevels.PENDING]: color.yellow,
-		[ListrDefaultRendererLogLevels.COMPLETED]: color.green,
-		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: color.yellow,
-		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS]: color.red,
-		[ListrDefaultRendererLogLevels.RETRY]: color.yellowBright,
-		[ListrDefaultRendererLogLevels.ROLLING_BACK]: color.redBright,
-		[ListrDefaultRendererLogLevels.ROLLED_BACK]: color.redBright,
-		[ListrDefaultRendererLogLevels.FAILED]: color.red,
-		[ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS]: color.red,
-		[ListrDefaultRendererLogLevels.WAITING]: color.dim,
-		[ListrDefaultRendererLogLevels.PAUSED]: color.yellowBright
+		["SKIPPED_WITH_COLLAPSE"]: color.yellow,
+		["SKIPPED_WITHOUT_COLLAPSE"]: color.yellow,
+		["PENDING"]: color.yellow,
+		["COMPLETED"]: color.green,
+		["COMPLETED_WITH_FAILED_SUBTASKS"]: color.yellow,
+		["COMPLETED_WITH_SISTER_TASKS_FAILED"]: color.red,
+		["RETRY"]: color.yellowBright,
+		["ROLLING_BACK"]: color.redBright,
+		["ROLLED_BACK"]: color.redBright,
+		["FAILED"]: color.red,
+		["FAILED_WITH_SUBTASKS"]: color.red,
+		["WAITING"]: color.dim,
+		["PAUSED"]: color.yellowBright,
+		["CANCELLED"]: color.red
 	}
 };
 
@@ -726,6 +792,9 @@ const PRESET_TIMESTAMP = {
 //#endregion
 //#region src/renderer/default/renderer.ts
 var DefaultRenderer = class DefaultRenderer {
+	tasks;
+	options;
+	events;
 	static nonTTY = false;
 	static rendererOptions = {
 		indentation: 2,
@@ -799,15 +868,14 @@ var DefaultRenderer = class DefaultRenderer {
 		if (!this.options?.lazy) this.spinner.start(() => {
 			this.update();
 		});
-		this.events.on(ListrEventType.SHOULD_REFRESH_RENDER, () => {
-			this.update();
-		});
+		this.events.on("SHOUD_REFRESH_RENDER", this.refresh);
 	}
 	update() {
 		this.updater(this.create());
 	}
 	end() {
 		this.spinner.stop();
+		this.events.off("SHOUD_REFRESH_RENDER", this.refresh);
 		this.updater.clear();
 		this.updater.done();
 		if (!this.options.clearOutput) this.logger.process.toStdout(this.create({ prompt: false }));
@@ -838,32 +906,33 @@ var DefaultRenderer = class DefaultRenderer {
 	style(task, output = false) {
 		const rendererOptions = this.cache.rendererOptions.get(task.id);
 		if (task.isSkipped()) {
-			if (output || rendererOptions.collapseSkips) return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE);
-			else if (rendererOptions.collapseSkips === false) return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE);
+			if (output || rendererOptions.collapseSkips) return this.logger.icon("SKIPPED_WITH_COLLAPSE");
+			else if (rendererOptions.collapseSkips === false) return this.logger.icon("SKIPPED_WITHOUT_COLLAPSE");
 		}
 		if (output) {
-			if (this.shouldOutputToBottomBar(task)) return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR);
-			return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT);
+			if (this.shouldOutputToBottomBar(task)) return this.logger.icon("OUTPUT_WITH_BOTTOMBAR");
+			return this.logger.icon("OUTPUT");
 		}
 		if (task.hasSubtasks()) {
-			if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) return this.logger.icon(ListrDefaultRendererLogLevels.PENDING);
-			else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS);
-			else if (task.hasFailed()) return this.logger.icon(ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS);
+			if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) return this.logger.icon("PENDING");
+			else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) return this.logger.icon("COMPLETED_WITH_FAILED_SUBTASKS");
+			else if (task.hasFailed()) return this.logger.icon("FAILED_WITH_SUBTASKS");
 		}
-		if (task.isStarted() || task.isPrompt()) return this.logger.icon(ListrDefaultRendererLogLevels.PENDING, !this.options?.lazy && this.spinner.fetch());
-		else if (task.isCompleted()) return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED);
-		else if (task.isRetrying()) return this.logger.icon(ListrDefaultRendererLogLevels.RETRY, !this.options?.lazy && this.spinner.fetch());
-		else if (task.isRollingBack()) return this.logger.icon(ListrDefaultRendererLogLevels.ROLLING_BACK, !this.options?.lazy && this.spinner.fetch());
-		else if (task.hasRolledBack()) return this.logger.icon(ListrDefaultRendererLogLevels.ROLLED_BACK);
-		else if (task.hasFailed()) return this.logger.icon(ListrDefaultRendererLogLevels.FAILED);
-		else if (task.isPaused()) return this.logger.icon(ListrDefaultRendererLogLevels.PAUSED);
-		return this.logger.icon(ListrDefaultRendererLogLevels.WAITING);
+		if (task.isStarted() || task.isPrompt()) return this.logger.icon("PENDING", !this.options?.lazy && this.spinner.fetch());
+		else if (task.isCompleted()) return this.logger.icon("COMPLETED");
+		else if (task.isRetrying()) return this.logger.icon("RETRY", !this.options?.lazy && this.spinner.fetch());
+		else if (task.isRollingBack()) return this.logger.icon("ROLLING_BACK", !this.options?.lazy && this.spinner.fetch());
+		else if (task.hasRolledBack()) return this.logger.icon("ROLLED_BACK");
+		else if (task.hasFailed()) return this.logger.icon("FAILED");
+		else if (task.isCancelled()) return this.logger.icon("CANCELLED");
+		else if (task.isPaused()) return this.logger.icon("PAUSED");
+		return this.logger.icon("WAITING");
 	}
 	format(message, icon, level) {
 		if (message.trim() === "") return [];
 		if (icon) message = icon + " " + message;
 		let parsed;
-		const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
+		const columns = (this.logger.process.stdout.columns ?? 80) - level * this.options.indentation - 2;
 		switch (this.options.formatOutput) {
 			case "truncate":
 				parsed = message.split(EOL).map((s, i) => {
@@ -889,6 +958,9 @@ var DefaultRenderer = class DefaultRenderer {
 		const bottomBar = this.cache.rendererTaskOptions.get(task.id).bottomBar;
 		return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
 	}
+	refresh = () => {
+		this.update();
+	};
 	renderer(tasks, level = 0) {
 		return tasks.flatMap((task) => {
 			if (!task.isEnabled()) return [];
@@ -901,28 +973,28 @@ var DefaultRenderer = class DefaultRenderer {
 			if (task.isPrompt()) {
 				if (this.activePrompt && this.activePrompt !== task.id) throw new ListrRendererError("Only one prompt can be active at the given time, please re-evaluate your task design.");
 				else if (!this.activePrompt) {
-					task.on(ListrTaskEventType.PROMPT, (prompt) => {
+					task.on("PROMPT", (prompt) => {
 						const cleansed = cleanseAnsi(prompt);
 						if (cleansed) this.prompt = cleansed;
 					});
-					task.on(ListrTaskEventType.STATE, (state) => {
-						if (state === ListrTaskState.PROMPT_COMPLETED || task.hasFinalized() || task.hasReset()) {
+					task.on("STATE", (state) => {
+						if (state === "PROMPT_COMPLETED" || task.hasFinalized() || task.hasReset()) {
 							this.prompt = null;
 							this.activePrompt = null;
-							task.off(ListrTaskEventType.PROMPT);
+							task.off("PROMPT");
 						}
 					});
 					this.activePrompt = task.id;
 				}
 			}
-			if (task.hasTitle()) if (!(tasks.some((task$1) => task$1.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
+			if (task.hasTitle()) if (!(tasks.some((task) => task.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped() || task.isCancelled()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
 			else if (task.isSkipped() && rendererOptions.collapseSkips) output.push(...this.format(this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
-				field: ListrLogLevels.SKIPPED,
+				field: "SKIPPED",
 				condition: rendererOptions.suffixSkips,
 				format: () => color.dim
 			}), this.style(task), level));
 			else if (task.isRetrying()) output.push(...this.format(this.logger.suffix(task.title, {
-				field: `${ListrLogLevels.RETRY}:${task.message.retry.count}`,
+				field: `${"RETRY"}:${task.message.retry.count}`,
 				format: () => color.yellow,
 				condition: rendererOptions.suffixRetries
 			}), this.style(task), level));
@@ -935,13 +1007,13 @@ var DefaultRenderer = class DefaultRenderer {
 				args: [task.message.paused - Date.now()]
 			}), this.style(task), level));
 			else output.push(...this.format(task.title, this.style(task), level));
-			else output.push(...this.format(task.title, this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS), level));
+			else output.push(...this.format(task.title, this.logger.icon("COMPLETED_WITH_SISTER_TASKS_FAILED"), level));
 			if (!task.hasSubtasks() || !rendererOptions.showSubtasks) {
-				if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, ListrLogLevels.FAILED));
-				else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, ListrLogLevels.SKIPPED));
+				if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "FAILED"));
+				else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "SKIPPED"));
 			}
 			if (task.isPending() || rendererTaskOptions.persistentOutput) output.push(...this.renderOutputBar(task, level));
-			if (rendererOptions.showSubtasks !== false && task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || task.subtasks.some((subtask) => subtask.hasFailed()) || task.subtasks.some((subtask) => subtask.hasRolledBack()))) {
+			if (rendererOptions.showSubtasks !== false && task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || task.subtasks.some((subtask) => subtask.hasFailed()) || task.subtasks.some((subtask) => subtask.hasRolledBack()) || task.subtasks.some((subtask) => subtask.isCancelled()))) {
 				const subtaskLevel = !task.hasTitle() ? level : level + 1;
 				const subtaskRender = this.renderer(task.subtasks, subtaskLevel);
 				output.push(...subtaskRender);
@@ -962,7 +1034,7 @@ var DefaultRenderer = class DefaultRenderer {
 	renderOutputBar(task, level) {
 		const output = this.buffer.output.get(task.id);
 		if (!output) return [];
-		return output.all.flatMap((o) => this.dump(task, level, ListrLogLevels.OUTPUT, o.entry));
+		return output.all.flatMap((o) => this.dump(task, level, "OUTPUT", o.entry));
 	}
 	renderBottomBar() {
 		if (this.buffer.bottom.size === 0) return [];
@@ -987,31 +1059,30 @@ var DefaultRenderer = class DefaultRenderer {
 	}
 	setupBuffer(task) {
 		if (this.buffer.bottom.has(task.id) || this.buffer.output.has(task.id)) return;
+		if (task.hasFinalized()) return;
 		const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
 		if (this.shouldOutputToBottomBar(task) && !this.buffer.bottom.has(task.id)) {
 			this.buffer.bottom.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.bottomBar === "number" ? rendererTaskOptions.bottomBar : 1 }));
-			task.on(ListrTaskEventType.OUTPUT, (output) => {
-				const data = this.dump(task, -1, ListrLogLevels.OUTPUT, output);
+			task.on("OUTPUT", (output) => {
+				const data = this.dump(task, -1, "OUTPUT", output);
 				this.buffer.bottom.get(task.id).write(data.join(EOL));
 			});
-			task.on(ListrTaskEventType.STATE, (state) => {
-				switch (state) {
-					case ListrTaskState.RETRY || ListrTaskState.ROLLING_BACK:
-						this.buffer.bottom.delete(task.id);
-						break;
-				}
+			task.on("OUTPUT_RESET", () => {
+				this.buffer.bottom.get(task.id)?.reset();
+			});
+			task.on("STATE", (state) => {
+				if (state === "RETRY" || state === "ROLLING_BACK") this.buffer.bottom.delete(task.id);
 			});
 		} else if (this.shouldOutputToOutputBar(task) && !this.buffer.output.has(task.id)) {
 			this.buffer.output.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.outputBar === "number" ? rendererTaskOptions.outputBar : 1 }));
-			task.on(ListrTaskEventType.OUTPUT, (output) => {
+			task.on("OUTPUT", (output) => {
 				this.buffer.output.get(task.id).write(output);
 			});
-			task.on(ListrTaskEventType.STATE, (state) => {
-				switch (state) {
-					case ListrTaskState.RETRY || ListrTaskState.ROLLING_BACK:
-						this.buffer.output.delete(task.id);
-						break;
-				}
+			task.on("OUTPUT_RESET", () => {
+				this.buffer.output.get(task.id)?.reset();
+			});
+			task.on("STATE", (state) => {
+				if (state === "RETRY" || state === "ROLLING_BACK") this.buffer.output.delete(task.id);
 			});
 		}
 	}
@@ -1020,20 +1091,20 @@ var DefaultRenderer = class DefaultRenderer {
 		this.cache.rendererTaskOptions.delete(task.id);
 		this.buffer.output.delete(task.id);
 	}
-	dump(task, level, source = ListrLogLevels.OUTPUT, data) {
+	dump(task, level, source = "OUTPUT", data) {
 		if (!data) switch (source) {
-			case ListrLogLevels.OUTPUT:
+			case "OUTPUT":
 				data = task.output;
 				break;
-			case ListrLogLevels.SKIPPED:
+			case "SKIPPED":
 				data = task.message.skip;
 				break;
-			case ListrLogLevels.FAILED:
+			case "FAILED":
 				data = task.message.error;
 				break;
 		}
-		if (task.hasTitle() && source === ListrLogLevels.FAILED && data === task.title || typeof data !== "string") return [];
-		if (source === ListrLogLevels.OUTPUT) data = cleanseAnsi(data);
+		if (task.hasTitle() && source === "FAILED" && data === task.title || typeof data !== "string") return [];
+		if (source === "OUTPUT") data = cleanseAnsi(data);
 		return this.format(data, this.style(task, true), level + 1);
 	}
 	indent(str, i) {
@@ -1044,6 +1115,8 @@ var DefaultRenderer = class DefaultRenderer {
 //#endregion
 //#region src/renderer/silent/renderer.ts
 var SilentRenderer = class {
+	tasks;
+	options;
 	static nonTTY = true;
 	static rendererOptions;
 	static rendererTaskOptions;
@@ -1058,10 +1131,12 @@ var SilentRenderer = class {
 //#endregion
 //#region src/renderer/simple/renderer.ts
 var SimpleRenderer = class SimpleRenderer {
+	tasks;
+	options;
 	static nonTTY = true;
 	static rendererOptions = { pausedTimer: {
 		...PRESET_TIMER,
-		field: (time) => `${ListrLogLevels.PAUSED}:${time}`,
+		field: (time) => `${"PAUSED"}:${time}`,
 		format: () => color.yellowBright
 	} };
 	static rendererTaskOptions = {};
@@ -1100,57 +1175,57 @@ var SimpleRenderer = class SimpleRenderer {
 	renderer(tasks) {
 		tasks.forEach((task) => {
 			this.calculate(task);
-			task.once(ListrTaskEventType.CLOSED, () => {
+			task.once("CLOSED", () => {
 				this.reset(task);
 			});
 			const rendererOptions = this.cache.rendererOptions.get(task.id);
 			const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
-			task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+			task.on("SUBTASK", (subtasks) => {
 				this.renderer(subtasks);
 			});
-			task.on(ListrTaskEventType.STATE, (state) => {
+			task.on("STATE", (state) => {
 				if (!task.hasTitle()) return;
-				if (state === ListrTaskState.STARTED) this.logger.log(ListrLogLevels.STARTED, task.title);
-				else if (state === ListrTaskState.COMPLETED) {
+				if (state === "STARTED") this.logger.log("STARTED", task.title);
+				else if (state === "COMPLETED") {
 					const timer = rendererTaskOptions?.timer;
-					this.logger.log(ListrLogLevels.COMPLETED, task.title, timer && { suffix: {
+					this.logger.log("COMPLETED", task.title, timer && { suffix: {
 						...timer,
 						condition: !!task.message?.duration && timer.condition,
 						args: [task.message.duration]
 					} });
-				} else if (state === ListrTaskState.PROMPT) {
+				} else if (state === "PROMPT") {
 					this.logger.process.hijack();
-					task.on(ListrTaskEventType.PROMPT, (prompt) => {
+					task.on("PROMPT", (prompt) => {
 						this.logger.process.toStderr(prompt, false);
 					});
-				} else if (state === ListrTaskState.PROMPT_COMPLETED) {
-					task.off(ListrTaskEventType.PROMPT);
+				} else if (state === "PROMPT_COMPLETED") {
+					task.off("PROMPT");
 					this.logger.process.release();
-				}
+				} else if (state === "CANCELLED") this.logger.log("CANCELLED", task.title);
 			});
-			task.on(ListrTaskEventType.OUTPUT, (output) => {
-				this.logger.log(ListrLogLevels.OUTPUT, output);
+			task.on("OUTPUT", (output) => {
+				this.logger.log("OUTPUT", output);
 			});
-			task.on(ListrTaskEventType.MESSAGE, (message) => {
-				if (message.error) this.logger.log(ListrLogLevels.FAILED, task.title, { suffix: {
-					field: `${ListrLogLevels.FAILED}: ${message.error}`,
+			task.on("MESSAGE", (message) => {
+				if (message.error) this.logger.log("FAILED", task.title, { suffix: {
+					field: `${"FAILED"}: ${message.error}`,
 					format: () => color.red
 				} });
-				else if (message.skip) this.logger.log(ListrLogLevels.SKIPPED, task.title, { suffix: {
-					field: `${ListrLogLevels.SKIPPED}: ${message.skip}`,
+				else if (message.skip) this.logger.log("SKIPPED", task.title, { suffix: {
+					field: `${"SKIPPED"}: ${message.skip}`,
 					format: () => color.yellow
 				} });
-				else if (message.rollback) this.logger.log(ListrLogLevels.ROLLBACK, task.title, { suffix: {
-					field: `${ListrLogLevels.ROLLBACK}: ${message.rollback}`,
+				else if (message.rollback) this.logger.log("ROLLBACK", task.title, { suffix: {
+					field: `${"ROLLBACK"}: ${message.rollback}`,
 					format: () => color.red
 				} });
-				else if (message.retry) this.logger.log(ListrLogLevels.RETRY, task.title, { suffix: {
-					field: `${ListrLogLevels.RETRY}:${message.retry.count}`,
+				else if (message.retry) this.logger.log("RETRY", task.title, { suffix: {
+					field: `${"RETRY"}:${message.retry.count}`,
 					format: () => color.red
 				} });
 				else if (message.paused) {
 					const timer = rendererOptions?.pausedTimer;
-					this.logger.log(ListrLogLevels.PAUSED, task.title, timer && { suffix: {
+					this.logger.log("PAUSED", task.title, timer && { suffix: {
 						...timer,
 						condition: !!message?.paused && timer.condition,
 						args: [message.paused - Date.now()]
@@ -1181,6 +1256,7 @@ var SimpleRenderer = class SimpleRenderer {
 //#endregion
 //#region src/renderer/test/serializer.ts
 var TestRendererSerializer = class {
+	options;
 	constructor(options) {
 		this.options = options;
 	}
@@ -1207,6 +1283,8 @@ var TestRendererSerializer = class {
 //#endregion
 //#region src/renderer/test/renderer.ts
 var TestRenderer = class TestRenderer {
+	tasks;
+	options;
 	static nonTTY = true;
 	static rendererOptions = {
 		subtasks: true,
@@ -1239,7 +1317,7 @@ var TestRenderer = class TestRenderer {
 			"isPrompt",
 			"isPaused",
 			"isPending",
-			"isSkipped",
+			"isCancelled",
 			"isStarted",
 			"hasFailed",
 			"isEnabled",
@@ -1266,27 +1344,27 @@ var TestRenderer = class TestRenderer {
 	end() {}
 	renderer(tasks) {
 		tasks.forEach((task) => {
-			if (this.options.subtasks) task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+			if (this.options.subtasks) task.on("SUBTASK", (subtasks) => {
 				this.renderer(subtasks);
 			});
-			if (this.options.state) task.on(ListrTaskEventType.STATE, (state) => {
-				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.STATE, state, task));
+			if (this.options.state) task.on("STATE", (state) => {
+				this.logger.toStdout(this.serializer.serialize("STATE", state, task));
 			});
-			if (this.options.output) task.on(ListrTaskEventType.OUTPUT, (data) => {
-				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.OUTPUT, data, task));
+			if (this.options.output) task.on("OUTPUT", (data) => {
+				this.logger.toStdout(this.serializer.serialize("OUTPUT", data, task));
 			});
-			if (this.options.prompt) task.on(ListrTaskEventType.PROMPT, (prompt) => {
-				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.PROMPT, prompt, task));
+			if (this.options.prompt) task.on("PROMPT", (prompt) => {
+				this.logger.toStdout(this.serializer.serialize("PROMPT", prompt, task));
 			});
-			if (this.options.title) task.on(ListrTaskEventType.TITLE, (title) => {
-				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.TITLE, title, task));
+			if (this.options.title) task.on("TITLE", (title) => {
+				this.logger.toStdout(this.serializer.serialize("TITLE", title, task));
 			});
-			task.on(ListrTaskEventType.MESSAGE, (message) => {
+			task.on("MESSAGE", (message) => {
 				const parsed = Object.fromEntries(Object.entries(message).map(([key, value]) => {
 					if (this.options.messages.includes(key)) return [key, value];
 				}).filter(Boolean));
 				if (Object.keys(parsed).length > 0) {
-					const output = this.serializer.serialize(ListrTaskEventType.MESSAGE, parsed, task);
+					const output = this.serializer.serialize("MESSAGE", parsed, task);
 					if (this.options.messagesToStderr.some((state) => Object.keys(parsed).includes(state))) this.logger.toStderr(output);
 					else this.logger.toStdout(output);
 				}
@@ -1298,6 +1376,8 @@ var TestRenderer = class TestRenderer {
 //#endregion
 //#region src/renderer/verbose/renderer.ts
 var VerboseRenderer = class VerboseRenderer {
+	tasks;
+	options;
 	static nonTTY = true;
 	static rendererOptions = {
 		logTitleChange: false,
@@ -1342,44 +1422,44 @@ var VerboseRenderer = class VerboseRenderer {
 	renderer(tasks) {
 		tasks.forEach((task) => {
 			this.calculate(task);
-			task.once(ListrTaskEventType.CLOSED, () => {
+			task.once("CLOSED", () => {
 				this.reset(task);
 			});
 			const rendererOptions = this.cache.rendererOptions.get(task.id);
 			const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
-			task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+			task.on("SUBTASK", (subtasks) => {
 				this.renderer(subtasks);
 			});
-			task.on(ListrTaskEventType.STATE, (state) => {
+			task.on("STATE", (state) => {
 				if (!task.hasTitle()) return;
-				if (state === ListrTaskState.STARTED) this.logger.log(ListrLogLevels.STARTED, task.title);
-				else if (state === ListrTaskState.COMPLETED) {
+				if (state === "STARTED") this.logger.log("STARTED", task.title);
+				else if (state === "COMPLETED") {
 					const timer = rendererTaskOptions.timer;
-					this.logger.log(ListrLogLevels.COMPLETED, task.title, timer && { suffix: {
+					this.logger.log("COMPLETED", task.title, timer && { suffix: {
 						...timer,
 						condition: !!task.message?.duration && timer.condition,
 						args: [task.message.duration]
 					} });
-				}
+				} else if (state === "CANCELLED") this.logger.log("CANCELLED", task.title);
 			});
-			task.on(ListrTaskEventType.OUTPUT, (data) => {
-				this.logger.log(ListrLogLevels.OUTPUT, data);
+			task.on("OUTPUT", (data) => {
+				this.logger.log("OUTPUT", data);
 			});
-			task.on(ListrTaskEventType.PROMPT, (prompt) => {
+			task.on("PROMPT", (prompt) => {
 				const cleansed = cleanseAnsi(prompt);
-				if (cleansed) this.logger.log(ListrLogLevels.PROMPT, cleansed);
+				if (cleansed) this.logger.log("PROMPT", cleansed);
 			});
-			if (this.options?.logTitleChange !== false) task.on(ListrTaskEventType.TITLE, (title) => {
-				this.logger.log(ListrLogLevels.TITLE, title);
+			if (this.options?.logTitleChange !== false) task.on("TITLE", (title) => {
+				this.logger.log("TITLE", title);
 			});
-			task.on(ListrTaskEventType.MESSAGE, (message) => {
-				if (message?.error) this.logger.log(ListrLogLevels.FAILED, message.error);
-				else if (message?.skip) this.logger.log(ListrLogLevels.SKIPPED, message.skip);
-				else if (message?.rollback) this.logger.log(ListrLogLevels.ROLLBACK, message.rollback);
-				else if (message?.retry) this.logger.log(ListrLogLevels.RETRY, task.title, { suffix: message.retry.count.toString() });
+			task.on("MESSAGE", (message) => {
+				if (message?.error) this.logger.log("FAILED", message.error);
+				else if (message?.skip) this.logger.log("SKIPPED", message.skip);
+				else if (message?.rollback) this.logger.log("ROLLBACK", message.rollback);
+				else if (message?.retry) this.logger.log("RETRY", task.title, { suffix: message.retry.count.toString() });
 				else if (message?.paused) {
 					const timer = rendererOptions?.pausedTimer;
-					this.logger.log(ListrLogLevels.PAUSED, task.title, timer && { suffix: {
+					this.logger.log("PAUSED", task.title, timer && { suffix: {
 						...timer,
 						condition: !!message?.paused && timer.condition,
 						args: [message.paused - Date.now()]
@@ -1426,17 +1506,17 @@ function getRendererClass(renderer) {
 function getRenderer(options) {
 	if (assertFunctionOrSelf(options?.silentRendererCondition)) return {
 		renderer: getRendererClass("silent"),
-		selection: ListrRendererSelection.SILENT
+		selection: "SILENT"
 	};
 	const r = {
 		renderer: getRendererClass(options.renderer),
 		options: options.rendererOptions,
-		selection: ListrRendererSelection.PRIMARY
+		selection: "PRIMARY"
 	};
 	if (!isRendererSupported(r.renderer) || assertFunctionOrSelf(options?.fallbackRendererCondition)) return {
 		renderer: getRendererClass(options.fallbackRenderer),
 		options: options.fallbackRendererOptions,
-		selection: ListrRendererSelection.SECONDARY
+		selection: "SECONDARY"
 	};
 	return r;
 }
@@ -1453,16 +1533,6 @@ function assertFunctionOrSelf(functionOrSelf, ...args) {
 	else return functionOrSelf;
 }
 
-//#endregion
-//#region src/utils/clone.ts
-const clone = rfdc({ circles: true });
-/**
-* Deep clones a object in the easiest manner.
-*/
-function cloneObject(obj) {
-	return clone(obj);
-}
-
 //#endregion
 //#region src/utils/concurrency.ts
 var Concurrency = class {
@@ -1510,47 +1580,6 @@ function delay(time) {
 	});
 }
 
-//#endregion
-//#region src/interfaces/listr-error.interface.ts
-/**
-* Internal error handling mechanism for Listr collects the errors and details for a failed task.
-*
-* @see {@link https://listr2.kilic.dev/task/error-handling.html}
-*/
-var ListrError = class extends Error {
-	path;
-	ctx;
-	constructor(error, type, task) {
-		super(error.message);
-		this.error = error;
-		this.type = type;
-		this.task = task;
-		this.name = "ListrError";
-		this.path = task.path;
-		if (task?.options.collectErrors === "full") {
-			this.task = cloneObject(task);
-			this.ctx = cloneObject(task.listr.ctx);
-		}
-		this.stack = error?.stack;
-	}
-};
-
-//#endregion
-//#region src/interfaces/listr-renderer-error.interface.ts
-/**
-* Internal error coming from renderer.
-*/
-var ListrRendererError = class extends Error {};
-
-//#endregion
-//#region src/interfaces/prompt-error.interface.ts
-/**
-* Internal error handling mechanism for Listr prompts to identify the failing cause is coming from a prompt.
-*
-* @see {@link https://listr2.kilic.dev/task/prompts.html}
-*/
-var PromptError = class extends Error {};
-
 //#endregion
 //#region src/lib/task-wrapper.ts
 /**
@@ -1559,6 +1588,7 @@ var PromptError = class extends Error {};
 * @see {@link https://listr2.kilic.dev/task/task.html}
 */
 var TaskWrapper = class {
+	task;
 	constructor(task) {
 		this.task = task;
 	}
@@ -1586,6 +1616,10 @@ var TaskWrapper = class {
 	* @see {@link https://listr2.kilic.dev/task/output.html}
 	*/
 	set output(output) {
+		if (output === null) {
+			this.task.outputReset$ = null;
+			return;
+		}
 		output = Array.isArray(output) ? output : [output];
 		this.task.output$ = splat(output.shift(), ...output);
 	}
@@ -1595,6 +1629,22 @@ var TaskWrapper = class {
 		this.task.promptOutput$ = output;
 	}
 	/**
+	* The `AbortSignal` for the current run, aborted when the run is interrupted (e.g. `SIGINT`).
+	* Wire it into your own async work (`fetch`, child processes, timers) to cancel cooperatively.
+	*
+	* @see {@link https://listr2.kilic.dev/task/rollback.html}
+	*/
+	get signal() {
+		return this.task.listr.signal;
+	}
+	/**
+	* Interrupt the whole run programmatically, as if it received a `SIGINT`.
+	* The other in-flight tasks roll back or are marked as cancelled, then the process exits with `127`.
+	*/
+	cancel() {
+		this.task.listr.cancel();
+	}
+	/**
 	* Creates a new set of Listr subtasks.
 	*
 	* @see {@link https://listr2.kilic.dev/task/subtasks.html}
@@ -1611,7 +1661,7 @@ var TaskWrapper = class {
 	* @see {@link https://listr2.kilic.dev/task/error-handling.html}
 	*/
 	report(error, type) {
-		if (this.task.options.collectErrors !== false) this.task.listr.errors.push(new ListrError(error, type, this.task));
+		if (this.task.options.collectErrors) this.task.listr.errors?.push(new ListrError(error, type, this.task));
 		this.task.message$ = { error: error.message ?? this.task?.title };
 	}
 	/**
@@ -1620,7 +1670,7 @@ var TaskWrapper = class {
 	* @see {@link https://listr2.kilic.dev/task/skip.html}
 	*/
 	skip(message, ...metadata) {
-		this.task.state$ = ListrTaskState.SKIPPED;
+		this.task.state$ = "SKIPPED";
 		if (message) this.task.message$ = { skip: message ? splat(message, ...metadata) : this.task?.title };
 	}
 	/**
@@ -1653,7 +1703,7 @@ var TaskWrapper = class {
 	stdout(type) {
 		return createWritable((chunk) => {
 			switch (type) {
-				case ListrTaskEventType.PROMPT:
+				case "PROMPT":
 					this.promptOutput = chunk;
 					break;
 				default: this.output = chunk;
@@ -1676,10 +1726,15 @@ var ListrTaskEventManager = class extends EventManager {};
 * Creates and handles a runnable instance of the Task.
 */
 var Task = class extends ListrTaskEventManager {
+	listr;
+	task;
+	options;
+	rendererOptions;
+	rendererTaskOptions;
 	/** Unique id per task, can be used for identifying a Task. */
 	id = randomUUID();
 	/** The current state of the task. */
-	state = ListrTaskState.WAITING;
+	state = "WAITING";
 	/** Subtasks of the current task. */
 	subtasks;
 	/** Title of the task. */
@@ -1726,26 +1781,34 @@ var Task = class extends ListrTaskEventManager {
 	*/
 	set state$(state) {
 		this.state = state;
-		this.emit(ListrTaskEventType.STATE, state);
+		this.emit("STATE", state);
 		if (this.hasSubtasks() && this.hasFailed()) {
-			for (const subtask of this.subtasks) if (subtask.state === ListrTaskState.STARTED) subtask.state$ = ListrTaskState.FAILED;
+			for (const subtask of this.subtasks) if (subtask.state === "STARTED") subtask.state$ = "FAILED";
 		}
-		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
 	}
 	/**
 	* Update the current output of the Task and emit the neccassary events.
 	*/
 	set output$(data) {
 		this.output = data;
-		this.emit(ListrTaskEventType.OUTPUT, data);
-		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.emit("OUTPUT", data);
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
+	}
+	/**
+	* Reset the current output of the Task and emit the neccassary events.
+	*/
+	set outputReset$(data) {
+		this.output = data;
+		this.emit("OUTPUT_RESET");
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
 	}
 	/**
 	* Update the current prompt output of the Task and emit the neccassary events.
 	*/
 	set promptOutput$(data) {
-		this.emit(ListrTaskEventType.PROMPT, data);
-		if (cleanseAnsi(data)) this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.emit("PROMPT", data);
+		if (cleanseAnsi(data)) this.listr.events.emit("SHOUD_REFRESH_RENDER");
 	}
 	/**
 	* Update or extend the current message of the Task and emit the neccassary events.
@@ -1755,16 +1818,16 @@ var Task = class extends ListrTaskEventManager {
 			...this.message,
 			...data
 		};
-		this.emit(ListrTaskEventType.MESSAGE, data);
-		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.emit("MESSAGE", data);
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
 	}
 	/**
 	* Update the current title of the Task and emit the neccassary events.
 	*/
 	set title$(title) {
 		this.title = title;
-		this.emit(ListrTaskEventType.TITLE, title);
-		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.emit("TITLE", title);
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
 	}
 	/**
 	* Current task path in the hierarchy.
@@ -1776,10 +1839,10 @@ var Task = class extends ListrTaskEventManager {
 	* Checks whether the current task with the given context should be set as enabled.
 	*/
 	async check(ctx) {
-		if (this.state === ListrTaskState.WAITING) {
+		if (this.state === "WAITING") {
 			this.enabled = await assertFunctionOrSelf(this.task?.enabled ?? true, ctx);
-			this.emit(ListrTaskEventType.ENABLED, this.enabled);
-			this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+			this.emit("ENABLED", this.enabled);
+			this.listr.events.emit("SHOUD_REFRESH_RENDER");
 		}
 		return this.enabled;
 	}
@@ -1789,7 +1852,7 @@ var Task = class extends ListrTaskEventManager {
 	}
 	/** Returns whether this task is finalized in someform. */
 	hasFinalized() {
-		return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack();
+		return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack() || this.isCancelled();
 	}
 	/** Returns whether this task is in progress. */
 	isPending() {
@@ -1797,35 +1860,39 @@ var Task = class extends ListrTaskEventManager {
 	}
 	/** Returns whether this task has started. */
 	isStarted() {
-		return this.state === ListrTaskState.STARTED;
+		return this.state === "STARTED";
 	}
 	/** Returns whether this task is skipped. */
 	isSkipped() {
-		return this.state === ListrTaskState.SKIPPED;
+		return this.state === "SKIPPED";
 	}
 	/** Returns whether this task has been completed. */
 	isCompleted() {
-		return this.state === ListrTaskState.COMPLETED;
+		return this.state === "COMPLETED";
 	}
 	/** Returns whether this task has been failed. */
 	hasFailed() {
-		return this.state === ListrTaskState.FAILED;
+		return this.state === "FAILED";
+	}
+	/** Returns whether this task has been cancelled by an interruption. */
+	isCancelled() {
+		return this.state === "CANCELLED";
 	}
 	/** Returns whether this task has an active rollback task going on. */
 	isRollingBack() {
-		return this.state === ListrTaskState.ROLLING_BACK;
+		return this.state === "ROLLING_BACK";
 	}
 	/** Returns whether the rollback action was successful. */
 	hasRolledBack() {
-		return this.state === ListrTaskState.ROLLED_BACK;
+		return this.state === "ROLLED_BACK";
 	}
 	/** Returns whether this task has an actively retrying task going on. */
 	isRetrying() {
-		return this.state === ListrTaskState.RETRY;
+		return this.state === "RETRY";
 	}
 	/** Returns whether this task has some kind of reset like retry and rollback going on. */
 	hasReset() {
-		return this.state === ListrTaskState.RETRY || this.state === ListrTaskState.ROLLING_BACK;
+		return this.state === "RETRY" || this.state === "ROLLING_BACK";
 	}
 	/** Returns whether enabled function resolves to true. */
 	isEnabled() {
@@ -1837,11 +1904,11 @@ var Task = class extends ListrTaskEventManager {
 	}
 	/** Returns whether this task has a prompt inside. */
 	isPrompt() {
-		return this.state === ListrTaskState.PROMPT;
+		return this.state === "PROMPT";
 	}
 	/** Returns whether this task is currently paused. */
 	isPaused() {
-		return this.state === ListrTaskState.PAUSED;
+		return this.state === "PAUSED";
 	}
 	/** Returns whether this task is closed. */
 	isClosed() {
@@ -1850,7 +1917,7 @@ var Task = class extends ListrTaskEventManager {
 	/** Pause the given task for certain time. */
 	async pause(time) {
 		const state = this.state;
-		this.state$ = ListrTaskState.PAUSED;
+		this.state$ = "PAUSED";
 		this.message$ = { paused: Date.now() + time };
 		await delay(time);
 		this.state$ = state;
@@ -1867,7 +1934,7 @@ var Task = class extends ListrTaskEventManager {
 				result.rendererClass = getRendererClass("silent");
 				this.subtasks = result.tasks;
 				result.errors = this.listr.errors;
-				this.emit(ListrTaskEventType.SUBTASK, this.subtasks);
+				this.emit("SUBTASK", this.subtasks);
 				result = result.run(context);
 			} else if (result instanceof Promise) result = result.then(handleResult);
 			else if (isReadable(result)) result = new Promise((resolve, reject) => {
@@ -1889,22 +1956,23 @@ var Task = class extends ListrTaskEventManager {
 			return result;
 		};
 		const startTime = Date.now();
-		this.state$ = ListrTaskState.STARTED;
+		this.state$ = "STARTED";
 		const skipped = await assertFunctionOrSelf(this.task?.skip ?? false, context);
 		if (skipped) {
 			if (typeof skipped === "string") this.message$ = { skip: skipped };
 			else if (this.hasTitle()) this.message$ = { skip: this.title };
 			else this.message$ = { skip: "Skipped task without a title." };
-			this.state$ = ListrTaskState.SKIPPED;
+			this.state$ = "SKIPPED";
 			return;
 		}
 		try {
 			const retryCount = typeof this.task?.retry === "number" && this.task.retry > 0 ? this.task.retry + 1 : typeof this.task?.retry === "object" && this.task.retry.tries > 0 ? this.task.retry.tries + 1 : 1;
 			const retryDelay = typeof this.task.retry === "object" && this.task.retry.delay;
 			for (let retries = 1; retries <= retryCount; retries++) try {
-				await handleResult(this.taskFn(context, wrapper));
+				await Promise.race([handleResult(this.taskFn(context, wrapper)), this.whenInterrupted()]);
 				break;
 			} catch (err) {
+				if (this.listr.signal.aborted) throw err;
 				if (retries !== retryCount) {
 					this.retry = {
 						count: retries,
@@ -1913,27 +1981,27 @@ var Task = class extends ListrTaskEventManager {
 					this.message$ = { retry: this.retry };
 					this.title$ = this.initialTitle;
 					this.output = void 0;
-					wrapper.report(err, ListrErrorTypes.WILL_RETRY);
-					this.state$ = ListrTaskState.RETRY;
+					wrapper.report(err, "WILL_RETRY");
+					this.state$ = "RETRY";
 					if (retryDelay) await this.pause(retryDelay);
 				} else throw err;
 			}
 			if (this.isStarted() || this.isRetrying()) {
 				this.message$ = { duration: Date.now() - startTime };
-				this.state$ = ListrTaskState.COMPLETED;
+				this.state$ = "COMPLETED";
 			}
 		} catch (error) {
 			if (this.prompt instanceof PromptError) error = this.prompt;
 			if (this.task?.rollback) {
-				wrapper.report(error, ListrErrorTypes.WILL_ROLLBACK);
+				wrapper.report(error, "WILL_ROLLBACK");
 				try {
-					this.state$ = ListrTaskState.ROLLING_BACK;
+					this.state$ = "ROLLING_BACK";
 					await this.task.rollback(context, wrapper);
 					this.message$ = { rollback: this.title };
-					this.state$ = ListrTaskState.ROLLED_BACK;
+					this.state$ = "ROLLED_BACK";
 				} catch (err) {
-					this.state$ = ListrTaskState.FAILED;
-					wrapper.report(err, ListrErrorTypes.HAS_FAILED_TO_ROLLBACK);
+					this.state$ = "FAILED";
+					wrapper.report(err, "HAS_FAILED_TO_ROLLBACK");
 					this.close();
 					throw err;
 				}
@@ -1942,22 +2010,38 @@ var Task = class extends ListrTaskEventManager {
 					throw error;
 				}
 			} else {
-				this.state$ = ListrTaskState.FAILED;
+				if (this.listr.signal.aborted) {
+					this.state$ = "CANCELLED";
+					throw error;
+				}
+				this.state$ = "FAILED";
 				if (this.listr.options.exitOnError !== false && await assertFunctionOrSelf(this.task?.exitOnError, context) !== false) {
-					wrapper.report(error, ListrErrorTypes.HAS_FAILED);
+					wrapper.report(error, "HAS_FAILED");
 					this.close();
 					throw error;
-				} else if (!this.hasSubtasks()) wrapper.report(error, ListrErrorTypes.HAS_FAILED_WITHOUT_ERROR);
+				} else if (!this.hasSubtasks()) wrapper.report(error, "HAS_FAILED_WITHOUT_ERROR");
 			}
 		} finally {
 			this.close();
 		}
 	}
 	close() {
-		this.emit(ListrTaskEventType.CLOSED);
-		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.emit("CLOSED");
+		this.listr.events.emit("SHOUD_REFRESH_RENDER");
 		this.complete();
 	}
+	whenInterrupted() {
+		return new Promise((_, reject) => {
+			const onAbort = () => {
+				if (!this.hasSubtasks()) reject(/* @__PURE__ */ new Error("Interrupted."));
+			};
+			if (this.listr.signal.aborted) {
+				onAbort();
+				return;
+			}
+			this.listr.signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
 };
 
 //#endregion
@@ -1972,8 +2056,11 @@ var ListrEventManager = class extends EventManager {};
 * @see {@link https://listr2.kilic.dev/listr/listr.html}
 */
 var Listr = class {
+	task;
+	options;
+	parentTask;
 	tasks = [];
-	errors = [];
+	errors;
 	ctx;
 	events;
 	path = [];
@@ -1981,8 +2068,11 @@ var Listr = class {
 	rendererClassOptions;
 	rendererSelection;
 	boundSignalHandler;
+	signal;
 	concurrency;
 	renderer;
+	abortController;
+	startedTasks = [];
 	constructor(task, options, parentTask) {
 		this.task = task;
 		this.options = options;
@@ -2004,16 +2094,22 @@ var Listr = class {
 		if (parentTask) {
 			this.path = [...parentTask.listr.path, parentTask.title];
 			this.errors = parentTask.listr.errors;
-		}
+		} else this.errors = this.options.collectErrors ? [] : null;
 		if (this.parentTask?.listr.events instanceof ListrEventManager) this.events = this.parentTask.listr.events;
 		else this.events = new ListrEventManager();
+		if (this.parentTask?.listr.abortController instanceof AbortController) this.abortController = this.parentTask.listr.abortController;
+		else {
+			this.abortController = new AbortController();
+			setMaxListeners(0, this.abortController.signal);
+		}
+		this.signal = this.abortController.signal;
 		/* istanbul ignore if */
-		if (this.options?.forceTTY || process.env[ListrEnvironmentVariables.FORCE_TTY]) {
+		if (this.options?.forceTTY || process.env["LISTR_FORCE_TTY"]) {
 			process.stdout.isTTY = true;
 			process.stderr.isTTY = true;
 		}
 		/* istanbul ignore if */
-		if (this.options?.forceUnicode) process.env[ListrEnvironmentVariables.FORCE_UNICODE] = "1";
+		if (this.options?.forceUnicode) process.env["LISTR_FORCE_UNICODE"] = "1";
 		const renderer = getRenderer({
 			renderer: this.options.renderer,
 			rendererOptions: this.options.rendererOptions,
@@ -2028,9 +2124,9 @@ var Listr = class {
 		/* istanbul ignore next */
 		this.add(task ?? []);
 		/* istanbul ignore if */
-		if (this.options.registerSignalListeners) {
+		if (this.options.registerSignalListeners && this.isRoot()) {
 			this.boundSignalHandler = this.signalHandler.bind(this);
-			process.once("SIGINT", this.boundSignalHandler).setMaxListeners(0);
+			process.on("SIGINT", this.boundSignalHandler).setMaxListeners(0);
 		}
 	}
 	/**
@@ -2062,46 +2158,73 @@ var Listr = class {
 		if (!this.renderer) this.renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
 		await this.renderer.render();
 		this.ctx = this.options?.ctx ?? context ?? {};
+		let error;
+		let failed = false;
 		try {
 			await Promise.all(this.tasks.map((task) => task.check(this.ctx)));
 			await Promise.all(this.tasks.map((task) => this.concurrency.add(() => this.runTask(task))));
-			this.renderer.end();
-			this.removeSignalHandler();
 		} catch (err) {
-			if (this.options.exitOnError !== false) {
-				this.renderer.end(err);
+			failed = true;
+			error = err;
+		}
+		if (this.signal.aborted) {
+			await Promise.allSettled(this.startedTasks);
+			if (this.isRoot()) {
+				this.cancelUnfinishedTasks();
+				this.renderer.end();
 				this.removeSignalHandler();
-				throw err;
+				process.exit(127);
+				return this.ctx;
 			}
+			throw error ?? /* @__PURE__ */ new Error("Interrupted.");
+		}
+		if (failed && this.options.exitOnError !== false) {
+			this.renderer.end(error);
+			this.removeSignalHandler();
+			throw error;
+		}
+		if (!failed) {
+			this.renderer.end();
+			this.removeSignalHandler();
 		}
 		return this.ctx;
 	}
+	/**
+	* Interrupt the running task list programmatically, as if it received a `SIGINT`.
+	*
+	* In-flight tasks roll back or are marked as cancelled and the process exits with `127`.
+	*/
+	cancel() {
+		this.abortController.abort();
+	}
 	generate(tasks) {
 		tasks = Array.isArray(tasks) ? tasks : [tasks];
 		return tasks.map((task) => {
 			let rendererTaskOptions;
-			if (this.rendererSelection === ListrRendererSelection.PRIMARY) rendererTaskOptions = task.rendererOptions;
-			else if (this.rendererSelection === ListrRendererSelection.SECONDARY) rendererTaskOptions = task.fallbackRendererOptions;
+			if (this.rendererSelection === "PRIMARY") rendererTaskOptions = task.rendererOptions;
+			else if (this.rendererSelection === "SECONDARY") rendererTaskOptions = task.fallbackRendererOptions;
 			return new Task(this, task, this.options, this.rendererClassOptions, rendererTaskOptions);
 		});
 	}
 	async runTask(task) {
 		if (!await task.check(this.ctx)) return;
-		return new TaskWrapper(task).run(this.ctx);
+		const promise = new TaskWrapper(task).run(this.ctx);
+		this.startedTasks.push(promise);
+		return promise;
 	}
 	signalHandler() {
-		this.tasks?.forEach(async (task) => {
-			if (task.isPending()) task.state$ = ListrTaskState.FAILED;
-		});
-		if (this.isRoot()) {
-			this.renderer?.end(/* @__PURE__ */ new Error("Interrupted."));
-			process.exit(127);
-		}
+		this.abortController.abort();
 	}
 	removeSignalHandler() {
 		if (this.boundSignalHandler) process.removeListener("SIGINT", this.boundSignalHandler);
 	}
+	cancelUnfinishedTasks(tasks = this.tasks) {
+		for (const task of tasks) {
+			if (task.hasSubtasks()) this.cancelUnfinishedTasks(task.subtasks);
+			if (task.isEnabled() !== false && !task.hasFinalized()) task.state$ = "CANCELLED";
+		}
+	}
 };
 
 //#endregion
-export { ANSI_ESCAPE, ANSI_ESCAPE_CODES, BaseEventMap, Concurrency, DefaultRenderer, EventManager, LISTR_DEFAULT_RENDERER_STYLE, LISTR_LOGGER_STDERR_LEVELS, LISTR_LOGGER_STYLE, Listr, ListrDefaultRendererLogLevels, ListrEnvironmentVariables, ListrError, ListrErrorTypes, ListrEventManager, ListrEventType, ListrLogLevels, ListrLogger, ListrPromptAdapter, ListrRendererError, ListrRendererSelection, ListrTaskEventManager, ListrTaskEventType, ListrTaskState, PRESET_TIMER, PRESET_TIMESTAMP, ProcessOutput, ProcessOutputBuffer, ProcessOutputStream, PromptError, SilentRenderer, SimpleRenderer, Spinner, TestRenderer, TestRendererSerializer, VerboseRenderer, assertFunctionOrSelf, cleanseAnsi, cloneObject, color, createWritable, delay, figures, getRenderer, getRendererClass, indent, isObservable, isReadable, isUnicodeSupported, parseTimer, parseTimestamp, splat };
+export { ANSI_ESCAPE, ANSI_ESCAPE_CODES, BaseEventMap, Concurrency, DefaultRenderer, EventManager, LISTR_DEFAULT_RENDERER_STYLE, LISTR_LOGGER_STDERR_LEVELS, LISTR_LOGGER_STYLE, Listr, ListrDefaultRendererLogLevels, ListrEnvironmentVariables, ListrError, ListrErrorTypes, ListrEventManager, ListrEventType, ListrLogLevels, ListrLogger, ListrPromptAdapter, ListrRendererError, ListrRendererSelection, ListrTaskEventManager, ListrTaskEventType, ListrTaskState, PRESET_TIMER, PRESET_TIMESTAMP, ProcessOutput, ProcessOutputBuffer, ProcessOutputStream, PromptError, SilentRenderer, SimpleRenderer, Spinner, TestRenderer, TestRendererSerializer, VerboseRenderer, assertFunctionOrSelf, cleanseAnsi, color, createWritable, delay, figures, getRenderer, getRendererClass, indent, isObservable, isReadable, isUnicodeSupported, parseTimer, parseTimestamp, splat };