@serenity-js/console-reporter 3.41.1 → 3.42.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.42.0](https://github.com/serenity-js/serenity-js/compare/v3.41.2...v3.42.0) (2026-03-19)
+
+
+### Features
+
+* **core:** add dual ESM/CJS build support for Wave 2 packages ([0e2631c](https://github.com/serenity-js/serenity-js/commit/0e2631ca7cdbe68da7feec343eaf4f7fe9bb64d6))
+* **core:** add ESM/CJS dual build support for web packages ([94c5a64](https://github.com/serenity-js/serenity-js/commit/94c5a6423dc369477bbabbacee5a54f8fca20209))
+
+
+
+
+
+## [3.41.2](https://github.com/serenity-js/serenity-js/compare/v3.41.1...v3.41.2) (2026-03-05)
+
+**Note:** Version bump only for package @serenity-js/console-reporter
+
+
+
+
+
 ## [3.41.1](https://github.com/serenity-js/serenity-js/compare/v3.41.0...v3.41.1) (2026-02-27)
 
 **Note:** Version bump only for package @serenity-js/console-reporter

package/esm/index.d.ts

@@ -0,0 +1,6 @@
+import type { StageCrewMemberBuilder } from '@serenity-js/core';
+import type { ConsoleReporterConfig } from './stage/index.js';
+import { ConsoleReporter } from './stage/index.js';
+export * from './stage/index.js';
+export default function create(config?: ConsoleReporterConfig): StageCrewMemberBuilder<ConsoleReporter>;
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,cAAc,kBAAkB,CAAC;AAEjC,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,MAAM,GAAE,qBAAiC,GAAG,sBAAsB,CAAC,eAAe,CAAC,CAEjH"}

package/esm/index.js

@@ -0,0 +1,6 @@
+import { ConsoleReporter } from './stage/index.js';
+export * from './stage/index.js';
+export default function create(config = undefined) {
+    return ConsoleReporter.fromJSON(config || { theme: 'auto' });
+}
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,cAAc,kBAAkB,CAAC;AAEjC,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,SAAgC,SAAS;IACpE,OAAO,eAAe,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;AACjE,CAAC"}

package/esm/stage/crew/console-reporter/ConsoleReporter.d.ts

@@ -0,0 +1,187 @@
+import type { ListensToDomainEvents, Stage, StageCrewMemberBuilder } from '@serenity-js/core';
+import type { DomainEvent } from '@serenity-js/core/events';
+import type { ConsoleReporterConfig } from './ConsoleReporterConfig.js';
+import { Printer } from './Printer.js';
+import type { TerminalTheme } from './themes/index.js';
+/**
+ * A [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/) that uses [standard output](https://en.wikipedia.org/wiki/Standard_streams)
+ * to report on progress of your Serenity/JS acceptance tests.
+ *
+ * `ConsoleReporter` ships with colour themes for both dark and light terminals,
+ * as well as a monochromatic theme for those moments when you're in a noir mood
+ * (or have a terminal that doesn't support colours, like the good old `cmd.exe` on Windows).
+ *
+ * ## Registering Console Reporter programmatically
+ *
+ * ```ts
+ *  import { configure } from '@serenity-js/core';
+ *  import { ConsoleReporter } from '@serenity-js/console-reporter';
+ *
+ *  configure({
+ *    crew: [
+ *      ConsoleReporter.withDefaultColourSupport()
+ *    ],
+ *  });
+ * ```
+ *
+ * ## Redirecting output to a file
+ *
+ * ```ts
+ *  import { configure } from '@serenity-js/core';
+ *  import { ConsoleReporter } from '@serenity-js/console-reporter';
+ *  import { createWriteStream } from 'node:fs';
+ *
+ *  configure({
+ *    outputStream: createWriteStream('./output.log'),
+ *    crew: [ ConsoleReporter.withDefaultColourSupport() ],
+ *  });
+ *  ```
+ *
+ * ## Registering Console Reporter with Playwright Test
+ *
+ * ```ts
+ * // playwright.config.ts
+ * import { devices } from '@playwright/test';
+ * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test';
+ *
+ * const config: PlaywrightTestConfig = {
+ *
+ *   reporter: [
+ *     [ 'line' ],
+ *     [ 'html', { open: 'never' } ],
+ *     [ '@serenity-js/playwright-test', {
+ *       crew: [
+ *         '@serenity-js/console-reporter',
+ *       ]
+ *     }]
+ *   ],
+ * }
+ * ```
+ *
+ * ## Registering Console Reporter with WebdriverIO
+ *
+ * ```ts
+ * // wdio.conf.ts
+ * import { ConsoleReporter } from '@serenity-js/console-reporter';
+ * import { WebdriverIOConfig } from '@serenity-js/webdriverio';
+ *
+ * export const config: WebdriverIOConfig = {
+ *
+ *   framework: '@serenity-js/webdriverio',
+ *
+ *   serenity: {
+ *     crew: [
+ *       '@serenity-js/console-reporter',
+ *     ]
+ *     // other Serenity/JS config
+ *   },
+ *
+ *  // other WebdriverIO config
+ * }
+ * ```
+ *
+ * ## Registering Console Reporter with Protractor
+ *
+ * ```js
+ * // protractor.conf.js
+ * const { ConsoleReporter } = require('@serenity-js/console-reporter');
+ *
+ * exports.config = {
+ *   framework:     'custom',
+ *   frameworkPath: require.resolve('@serenity-js/protractor/adapter'),
+ *
+ *   serenity: {
+ *     crew: [
+ *       '@serenity-js/console-reporter',
+ *     ],
+ *     // other Serenity/JS config
+ *   },
+ *
+ *   // other Protractor config
+ * }
+ * ```
+ *
+ * ## Changing the default colour theme
+ *
+ * ```js
+ *   // ...
+ *   serenity: {
+ *     crew: [
+ *       [ '@serenity-js/console-reporter', {
+ *         theme: 'light',
+ *         // theme: 'dark',
+ *         // theme: 'mono',
+ *         // theme: 'auto',
+ *       } ]
+ *     ],
+ *   },
+ *   //...
+ * ```
+ *
+ * @public
+ *
+ * @group Stage
+ */
+export declare class ConsoleReporter implements ListensToDomainEvents {
+    private readonly printer;
+    private readonly theme;
+    private readonly stage?;
+    private startTimes;
+    private artifacts;
+    private summary;
+    private readonly firstErrors;
+    private readonly summaryFormatter;
+    private readonly eventQueues;
+    static fromJSON(config: ConsoleReporterConfig): StageCrewMemberBuilder<ConsoleReporter>;
+    /**
+     * Instantiates a `ConsoleReporter` that auto-detects
+     * your terminal's support for colours and uses a colour theme
+     * for dark terminals if successful.
+     *
+     * Please note that spawning your test process from another process
+     * (by using [npm-failsafe](https://www.npmjs.com/package/npm-failsafe), for example)
+     * causes the `ConsoleReporter` to use the monochromatic colour scheme,
+     * as colour support can't be detected in child processes.
+     */
+    static withDefaultColourSupport(): StageCrewMemberBuilder<ConsoleReporter>;
+    /**
+     * Instantiates a `ConsoleReporter` with a monochromatic colour theme.
+     * Good for terminals with no colour support (like the `cmd.exe` on Windows),
+     * or for times when you need to pipe the output to a text file and want
+     * to avoid printing control characters.
+     */
+    static forMonochromaticTerminals(): StageCrewMemberBuilder<ConsoleReporter>;
+    /**
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with dark backgrounds.
+     */
+    static forDarkTerminals(): StageCrewMemberBuilder<ConsoleReporter>;
+    /**
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with light backgrounds.
+     */
+    static forLightTerminals(): StageCrewMemberBuilder<ConsoleReporter>;
+    private static theme;
+    /**
+     * @param {Printer} printer
+     * @param {TerminalTheme} theme
+     * @param {Stage} [stage=undefined]
+     */
+    constructor(printer: Printer, theme: TerminalTheme, stage?: Stage);
+    /**
+     * Handles [`DomainEvent`](https://serenity-js.org/api/core-events/class/DomainEvent/) objects emitted by the [`Stage`](https://serenity-js.org/api/core/class/Stage/).
+     *
+     * @see [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/)
+     *
+     * @listens {DomainEvent}
+     *
+     * @param {DomainEvent} event
+     */
+    notifyOf(event: DomainEvent): void;
+    private printTestRunErrorOutcome;
+    private printScene;
+    private printSummary;
+    private isSceneSpecific;
+    private formattedOutcome;
+    private deCamelCased;
+    private iconFrom;
+}
+//# sourceMappingURL=ConsoleReporter.d.ts.map

package/esm/stage/crew/console-reporter/ConsoleReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleReporter.d.ts","sourceRoot":"","sources":["../../../../src/stage/crew/console-reporter/ConsoleReporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,qBAAqB,EAAE,KAAK,EAAE,sBAAsB,EAAa,MAAM,mBAAmB,CAAC;AAGnH,OAAO,KAAK,EACR,WAAW,EAAC,MAAM,0BAA0B,CAAC;AA8BjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,KAAK,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsHG;AACH,qBAAa,eAAgB,YAAW,qBAAqB;IAsErD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IAtE3B,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IAEvD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,GAAG,sBAAsB,CAAC,eAAe,CAAC;IAIvF;;;;;;;;;OASG;IACH,MAAM,CAAC,wBAAwB,IAAI,sBAAsB,CAAC,eAAe,CAAC;IAI1E;;;;;OAKG;IACH,MAAM,CAAC,yBAAyB,IAAI,sBAAsB,CAAC,eAAe,CAAC;IAI3E;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,sBAAsB,CAAC,eAAe,CAAC;IAIlE;;OAEG;IACH,MAAM,CAAC,iBAAiB,IAAI,sBAAsB,CAAC,eAAe,CAAC;IAInE,OAAO,CAAC,MAAM,CAAC,KAAK;IAapB;;;;OAIG;gBAEkB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,KAAK;IAQlC;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IA+BlC,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,UAAU;IAmIlB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,QAAQ;CAqBnB"}

package/esm/stage/crew/console-reporter/ConsoleReporter.js

@@ -0,0 +1,423 @@
+import { AssertionError, d, DomainEventQueues, LogicError } from '@serenity-js/core';
+import { ActivityRelatedArtifactGenerated, InteractionFinished, InteractionStarts, SceneFinished, SceneStarts, TaskFinished, TaskStarts, TestRunFinished, TestRunStarts, } from '@serenity-js/core/events';
+import { ExecutionCompromised, ExecutionFailedWithAssertionError, ExecutionFailedWithError, ExecutionIgnored, ExecutionSkipped, ExecutionSuccessful, ImplementationPending, LogEntry, ProblemIndication, } from '@serenity-js/core/model';
+import chalk from 'chalk';
+import { ensure, isDefined, match } from 'tiny-types';
+import { Printer } from './Printer.js';
+import { Summary } from './Summary.js';
+import { SummaryFormatter } from './SummaryFormatter.js';
+import { ThemeForDarkTerminals, ThemeForLightTerminals, ThemeForMonochromaticTerminals } from './themes/index.js';
+const ChalkInstance = chalk.Instance;
+/**
+ * A [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/) that uses [standard output](https://en.wikipedia.org/wiki/Standard_streams)
+ * to report on progress of your Serenity/JS acceptance tests.
+ *
+ * `ConsoleReporter` ships with colour themes for both dark and light terminals,
+ * as well as a monochromatic theme for those moments when you're in a noir mood
+ * (or have a terminal that doesn't support colours, like the good old `cmd.exe` on Windows).
+ *
+ * ## Registering Console Reporter programmatically
+ *
+ * ```ts
+ *  import { configure } from '@serenity-js/core';
+ *  import { ConsoleReporter } from '@serenity-js/console-reporter';
+ *
+ *  configure({
+ *    crew: [
+ *      ConsoleReporter.withDefaultColourSupport()
+ *    ],
+ *  });
+ * ```
+ *
+ * ## Redirecting output to a file
+ *
+ * ```ts
+ *  import { configure } from '@serenity-js/core';
+ *  import { ConsoleReporter } from '@serenity-js/console-reporter';
+ *  import { createWriteStream } from 'node:fs';
+ *
+ *  configure({
+ *    outputStream: createWriteStream('./output.log'),
+ *    crew: [ ConsoleReporter.withDefaultColourSupport() ],
+ *  });
+ *  ```
+ *
+ * ## Registering Console Reporter with Playwright Test
+ *
+ * ```ts
+ * // playwright.config.ts
+ * import { devices } from '@playwright/test';
+ * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test';
+ *
+ * const config: PlaywrightTestConfig = {
+ *
+ *   reporter: [
+ *     [ 'line' ],
+ *     [ 'html', { open: 'never' } ],
+ *     [ '@serenity-js/playwright-test', {
+ *       crew: [
+ *         '@serenity-js/console-reporter',
+ *       ]
+ *     }]
+ *   ],
+ * }
+ * ```
+ *
+ * ## Registering Console Reporter with WebdriverIO
+ *
+ * ```ts
+ * // wdio.conf.ts
+ * import { ConsoleReporter } from '@serenity-js/console-reporter';
+ * import { WebdriverIOConfig } from '@serenity-js/webdriverio';
+ *
+ * export const config: WebdriverIOConfig = {
+ *
+ *   framework: '@serenity-js/webdriverio',
+ *
+ *   serenity: {
+ *     crew: [
+ *       '@serenity-js/console-reporter',
+ *     ]
+ *     // other Serenity/JS config
+ *   },
+ *
+ *  // other WebdriverIO config
+ * }
+ * ```
+ *
+ * ## Registering Console Reporter with Protractor
+ *
+ * ```js
+ * // protractor.conf.js
+ * const { ConsoleReporter } = require('@serenity-js/console-reporter');
+ *
+ * exports.config = {
+ *   framework:     'custom',
+ *   frameworkPath: require.resolve('@serenity-js/protractor/adapter'),
+ *
+ *   serenity: {
+ *     crew: [
+ *       '@serenity-js/console-reporter',
+ *     ],
+ *     // other Serenity/JS config
+ *   },
+ *
+ *   // other Protractor config
+ * }
+ * ```
+ *
+ * ## Changing the default colour theme
+ *
+ * ```js
+ *   // ...
+ *   serenity: {
+ *     crew: [
+ *       [ '@serenity-js/console-reporter', {
+ *         theme: 'light',
+ *         // theme: 'dark',
+ *         // theme: 'mono',
+ *         // theme: 'auto',
+ *       } ]
+ *     ],
+ *   },
+ *   //...
+ * ```
+ *
+ * @public
+ *
+ * @group Stage
+ */
+export class ConsoleReporter {
+    printer;
+    theme;
+    stage;
+    startTimes = new StartTimes();
+    artifacts = new ActivityRelatedArtifacts();
+    summary = new Summary();
+    firstErrors = new Map();
+    summaryFormatter;
+    eventQueues = new DomainEventQueues();
+    static fromJSON(config) {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme(config.theme));
+    }
+    /**
+     * Instantiates a `ConsoleReporter` that auto-detects
+     * your terminal's support for colours and uses a colour theme
+     * for dark terminals if successful.
+     *
+     * Please note that spawning your test process from another process
+     * (by using [npm-failsafe](https://www.npmjs.com/package/npm-failsafe), for example)
+     * causes the `ConsoleReporter` to use the monochromatic colour scheme,
+     * as colour support can't be detected in child processes.
+     */
+    static withDefaultColourSupport() {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('auto'));
+    }
+    /**
+     * Instantiates a `ConsoleReporter` with a monochromatic colour theme.
+     * Good for terminals with no colour support (like the `cmd.exe` on Windows),
+     * or for times when you need to pipe the output to a text file and want
+     * to avoid printing control characters.
+     */
+    static forMonochromaticTerminals() {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('mono'));
+    }
+    /**
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with dark backgrounds.
+     */
+    static forDarkTerminals() {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('dark'));
+    }
+    /**
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with light backgrounds.
+     */
+    static forLightTerminals() {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('light'));
+    }
+    static theme(theme) {
+        switch (theme) {
+            case 'dark':
+                return new ThemeForDarkTerminals(new ChalkInstance({ level: 2 }));
+            case 'light':
+                return new ThemeForLightTerminals(new ChalkInstance({ level: 2 }));
+            case 'mono':
+                return new ThemeForMonochromaticTerminals();
+            default:
+                return new ThemeForDarkTerminals(new ChalkInstance( /* auto-detect */));
+        }
+    }
+    /**
+     * @param {Printer} printer
+     * @param {TerminalTheme} theme
+     * @param {Stage} [stage=undefined]
+     */
+    constructor(printer, theme, stage) {
+        this.printer = printer;
+        this.theme = theme;
+        this.stage = stage;
+        ensure('printer', printer, isDefined());
+        ensure('theme', theme, isDefined());
+        this.summaryFormatter = new SummaryFormatter(this.theme);
+    }
+    /**
+     * Handles [`DomainEvent`](https://serenity-js.org/api/core-events/class/DomainEvent/) objects emitted by the [`Stage`](https://serenity-js.org/api/core/class/Stage/).
+     *
+     * @see [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/)
+     *
+     * @listens {DomainEvent}
+     *
+     * @param {DomainEvent} event
+     */
+    notifyOf(event) {
+        if (event instanceof TestRunStarts) {
+            this.summary.recordTestRunStartedAt(event.timestamp);
+        }
+        if (this.isSceneSpecific(event)) {
+            this.eventQueues.enqueue(event);
+        }
+        if (event instanceof SceneStarts) {
+            this.firstErrors.set(event.sceneId.value, new FirstError());
+            this.startTimes.recordStartOf(event);
+        }
+        if (event instanceof SceneFinished) {
+            this.printScene(event.sceneId);
+        }
+        if (event instanceof TestRunFinished) {
+            this.summary.recordTestRunFinishedAt(event.timestamp);
+            this.printSummary(this.summary);
+            if (event.outcome instanceof ProblemIndication) {
+                this.printTestRunErrorOutcome(event.outcome);
+            }
+        }
+    }
+    printTestRunErrorOutcome(outcome) {
+        this.printer.println(this.theme.outcome(outcome, outcome.error.stack));
+    }
+    printScene(sceneId) {
+        const events = this.eventQueues.drainQueueFor(sceneId);
+        for (const event of events) {
+            match(event)
+                .when(SceneStarts, (e) => {
+                const category = e.details.name.value ? `${e.details.category.value}: ` : '';
+                // Print scenario header
+                this.printer.println(this.theme.separator('-'));
+                this.printer.println(e.details.location.path.value, e.details.location.line ? `:${e.details.location.line}` : '');
+                this.printer.println();
+                this.printer.println(this.theme.heading(category, e.details.name.value));
+                this.printer.println();
+            })
+                .when(TaskStarts, (e) => {
+                this.printer.indent();
+                if (!this.firstErrors.get(e.sceneId.value)?.alreadyRecorded()) {
+                    this.printer.println(e.details.name.value);
+                }
+            })
+                .when(InteractionStarts, (e) => {
+                this.startTimes.recordStartOf(e);
+            })
+                .when(InteractionFinished, (e) => {
+                this.printer.indent();
+                this.printer.println(this.formattedOutcome(e));
+                this.printer.indent();
+                if (e.outcome instanceof ProblemIndication) {
+                    this.firstErrors.get(e.sceneId.value)?.recordIfNeeded(e.outcome.error);
+                    if (!(e.outcome.error instanceof AssertionError)) {
+                        this.printer.println(this.theme.outcome(e.outcome, `${e.outcome.error}`));
+                    }
+                }
+                const artifactGeneratedEvents = this.artifacts.recordedFor(e.activityId);
+                if (artifactGeneratedEvents.some(a => a instanceof LogEntry)) {
+                    this.printer.println();
+                }
+                artifactGeneratedEvents.forEach(artifactGenerated => {
+                    if (artifactGenerated.artifact instanceof LogEntry) {
+                        const details = artifactGenerated.artifact.map((artifactContents) => artifactContents.data);
+                        if (artifactGenerated.name.value !== details) {
+                            this.printer.println(this.theme.log(artifactGenerated.name.value, ':'));
+                        }
+                        this.printer.println(details);
+                        this.printer.println();
+                    }
+                });
+                this.printer.outdent();
+                this.printer.outdent();
+            })
+                .when(ActivityRelatedArtifactGenerated, (e) => {
+                this.artifacts.record(e);
+            })
+                .when(TaskFinished, (e) => {
+                this.printer.outdent();
+                if (e.outcome instanceof ProblemIndication) {
+                    this.printer.indent();
+                    this.printer.indent();
+                    if (!this.firstErrors.get(e.sceneId.value).alreadyRecorded()) {
+                        this.printer.println(this.theme.outcome(e.outcome, this.iconFrom(e.outcome), `${e.outcome.error}`));
+                    }
+                    this.printer.outdent();
+                    this.printer.outdent();
+                    this.firstErrors.get(e.sceneId.value).recordIfNeeded(e.outcome.error);
+                }
+                else if (!(e.outcome instanceof ExecutionSuccessful)) {
+                    this.printer.indent();
+                    this.printer.println(this.iconFrom(e.outcome), e.details.name.value);
+                    this.printer.outdent();
+                }
+            })
+                .when(SceneFinished, (e) => {
+                this.summary.record(e.details, e.outcome, this.startTimes.eventDurationOf(e));
+                this.printer.println();
+                this.printer.println(this.theme.outcome(e.outcome, this.formattedOutcome(e, this.deCamelCased(e.outcome.constructor.name))));
+                if (e.outcome instanceof ProblemIndication) {
+                    this.printer.println();
+                    this.printer.indent();
+                    if (e.outcome instanceof ImplementationPending) {
+                        this.printer.println(`${e.outcome.error.name}: ${e.outcome.error.message}`);
+                    }
+                    else if (e.outcome.error?.stack) {
+                        this.printer.println(e.outcome.error.stack);
+                    }
+                    this.printer.outdent();
+                }
+                this.artifacts.clear();
+            })
+                .else((_) => {
+                return void 0;
+            });
+        }
+    }
+    printSummary(summary) {
+        this.printer.println(this.theme.separator('='));
+        this.printer.print(this.summaryFormatter.format(summary.aggregated()));
+        this.printer.println(this.theme.separator('='));
+    }
+    isSceneSpecific(event) {
+        return Object.prototype.hasOwnProperty.call(event, 'sceneId');
+    }
+    formattedOutcome(event, description = event.details.name.value) {
+        const duration = this.startTimes.eventDurationOf(event);
+        const icon = this.iconFrom(event.outcome);
+        const message = description.split('\n').map((line, index) => index === 0
+            ? `${line} (${duration})`
+            : `${' '.repeat(icon.length)}${line}`).join('\n');
+        return (event.outcome instanceof ProblemIndication)
+            ? this.theme.outcome(event.outcome, `${icon}${message}`)
+            : `${this.theme.outcome(event.outcome, icon)}${message}`;
+    }
+    deCamelCased(name) {
+        const deCamelCased = name.replaceAll(/([^A-Z])([A-Z])/g, '$1 $2');
+        return deCamelCased.charAt(0).toUpperCase() + deCamelCased.slice(1).toLocaleLowerCase();
+    }
+    iconFrom(outcome) {
+        // Use instanceof instead of constructor comparison to work across ESM/CJS boundaries
+        if (outcome instanceof ExecutionCompromised ||
+            outcome instanceof ExecutionFailedWithError ||
+            outcome instanceof ExecutionFailedWithAssertionError) {
+            return '✗ ';
+        }
+        if (outcome instanceof ImplementationPending) {
+            return '☕';
+        }
+        if (outcome instanceof ExecutionSkipped) {
+            return '⇢ ';
+        }
+        if (outcome instanceof ExecutionIgnored) {
+            return '? ';
+        }
+        if (outcome instanceof ExecutionSuccessful) {
+            return '✓ ';
+        }
+        return '';
+    }
+}
+class ConsoleReporterBuilder {
+    theme;
+    constructor(theme) {
+        this.theme = theme;
+    }
+    build({ stage, outputStream }) {
+        return new ConsoleReporter(new Printer(outputStream), this.theme, stage);
+    }
+}
+class StartTimes {
+    times = {};
+    recordStartOf(event) {
+        this.times[this.keyFor(event)] = event.timestamp;
+    }
+    eventDurationOf(event) {
+        if (!this.times[this.keyFor(event)]) {
+            throw new LogicError(d `StartTime missing for event ${event}`);
+        }
+        return event.timestamp.diff(this.times[this.keyFor(event)]);
+    }
+    keyFor(event) {
+        return `${event.sceneId.toString()}:${event.activityId?.toString()}`;
+    }
+}
+class FirstError {
+    error;
+    recordIfNeeded(error) {
+        if (!this.error) {
+            this.error = error;
+        }
+    }
+    alreadyRecorded() {
+        return !!this.error;
+    }
+    get() {
+        return this.error;
+    }
+}
+class ActivityRelatedArtifacts {
+    events = [];
+    record(event) {
+        this.events.push(event);
+    }
+    recordedFor(activityId) {
+        return this.events
+            .filter(event => event.activityId.equals(activityId));
+    }
+    clear() {
+        this.events = [];
+    }
+}
+//# sourceMappingURL=ConsoleReporter.js.map