@serenity-js/core 3.42.2 → 3.43.1

package/src/stage/ActorLifecycleManager.ts

@@ -0,0 +1,314 @@
+import { ensure, isDefined, property } from 'tiny-types';
+
+import { ConfigurationError, LogicError, RaiseErrors } from '../errors/index.js';
+import { ActorEntersStage, ActorSpotlighted, } from '../events/index.js';
+import { CorrelationId } from '../model/index.js';
+import type { Clock, Duration } from '../screenplay/index.js';
+import { Actor, ScheduleWork } from '../screenplay/index.js';
+import type { Cast } from './Cast.js';
+import type { Stage } from './Stage.js';
+
+/**
+ * Represents the focus area where actors are tracked.
+ *
+ * - `'foreground'` - Scene-scoped actors that are dismissed when a scene finishes
+ * - `'background'` - Test run-scoped actors that persist across scenes and are dismissed when the test run finishes
+ *
+ * @group Stage
+ */
+export type StageFocus = 'foreground' | 'background';
+
+/**
+ * Manages the lifecycle of [actors](https://serenity-js.org/api/core/class/Actor/) on the [stage](https://serenity-js.org/api/core/class/Stage/),
+ * including their creation, retrieval, and tracking of which actors are in the foreground (scene-scoped)
+ * versus background (test run-scoped).
+ *
+ * The `ActorLifecycleManager` is responsible for:
+ * - Instantiating and caching actors via the configured [cast](https://serenity-js.org/api/core/class/Cast/)
+ * - Tracking which actor is currently in the spotlight (active)
+ * - Managing the focus area (foreground vs background) where new actors are created
+ * - Providing access to actors for dismissal when scenes or test runs finish
+ *
+ * ## Default behaviour
+ *
+ * By default, actors created before the actual test scenario starts, e.g. in beforeAll hooks, are placed in the `'background'` focus area.
+ * When a [`SceneStarts`](https://serenity-js.org/api/core-events/class/SceneStarts/) event is announced,
+ * the focus switches to `'foreground'`. When a [`SceneFinishes`](https://serenity-js.org/api/core-events/class/SceneFinishes/)
+ * event is announced, foreground actors are dismissed, their abilities [discarded](https://serenity-js.org/api/core/class/Discardable/)
+ * and focus returns to `'background'`.
+ *
+ * ## Custom lifecycle management
+ *
+ * Test runner adapters like [`@serenity-js/playwright-test`](https://serenity-js.org/api/playwright-test/),
+ * where test execution and reporting happen in separate processes, can inject a custom `ActorLifecycleManager` instance
+ * to control actor lifecycle programmatically.
+ *
+ * ```typescript
+ * const actorLifecycleManager = new ActorLifecycleManager(cast, clock, interactionTimeout);
+ * const serenity = new Serenity(clock, cueTimeout, actorLifecycleManager);
+ *
+ * // At the start of each test:
+ * actorLifecycleManager.switchFocus('foreground');
+ * ```
+ *
+ * ## Learn more
+ * - [`Stage`](https://serenity-js.org/api/core/class/Stage/)
+ * - [`Cast`](https://serenity-js.org/api/core/class/Cast/)
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ *
+ * @group Stage
+ */
+export class ActorLifecycleManager {
+
+    /**
+     * The most recent actor referenced via the {@apilink actor} method
+     */
+    private currentActor?: Actor;
+
+    /**
+     * The scene in which the spotlight was last set.
+     * Used to detect when the spotlight shifts to a different scene context.
+     */
+    private currentActorScene: CorrelationId = new CorrelationId('unknown');
+
+    private currentFocusValue: StageFocus = 'background';
+
+    private actors: Record<StageFocus, Map<string, Actor>> = {
+        'foreground': new Map<string, Actor>(),
+        'background': new Map<string, Actor>(),
+    }
+
+    protected stage: Stage;
+
+    constructor(
+        protected cast: Cast,
+        protected readonly clock: Clock,
+        protected interactionTimeout: Duration,
+    ) {
+    }
+
+    /**
+     * Configures the manager with new settings.
+     *
+     * @param options - Configuration options
+     * @param options.interactionTimeout - The maximum time to wait for an interaction to complete
+     */
+    configure({ interactionTimeout }: { interactionTimeout: Duration }): void {
+        this.interactionTimeout = interactionTimeout;
+    }
+
+    /**
+     * Associates this manager with a [`Stage`](https://serenity-js.org/api/core/class/Stage/) instance.
+     *
+     * This method is called automatically by the `Stage` during construction.
+     * It establishes the bidirectional relationship between the manager and the stage,
+     * allowing the manager to emit [domain events](https://serenity-js.org/api/core-events/class/DomainEvent/)
+     * when actors enter the stage or are spotlighted.
+     *
+     * @param stage - The Stage instance to associate with this manager
+     */
+    assignTo(stage: Stage): void {
+        this.stage = stage;
+    }
+
+    /**
+     * Configures the manager to use the provided [cast](https://serenity-js.org/api/core/class/Cast/) for preparing actors.
+     *
+     * @param actors - The cast to use for preparing new actors
+     *
+     * @throws [`ConfigurationError`](https://serenity-js.org/api/core/class/ConfigurationError/)
+     *  If the provided cast is not defined or doesn't have a `prepare` method
+     */
+    engage(actors: Cast): void {
+        this.cast = ensure('actors', actors, isDefined(), property('prepare', isDefined()));
+    }
+
+    /**
+     * Returns the current [cast](https://serenity-js.org/api/core/class/Cast/) used for preparing actors.
+     *
+     * @returns The currently configured cast
+     */
+    currentCast(): Cast {
+        return this.cast;
+    }
+
+    /**
+     * Instantiates a new [`Actor`](https://serenity-js.org/api/core/class/Actor/) or fetches an existing one
+     * identified by their name if they've already been instantiated.
+     *
+     * When a new actor is instantiated, an [`ActorEntersStage`](https://serenity-js.org/api/core-events/class/ActorEntersStage/)
+     * event is announced. When the spotlight shifts to a different actor (or the same actor in a different scene),
+     * an [`ActorSpotlighted`](https://serenity-js.org/api/core-events/class/ActorSpotlighted/) event is announced.
+     *
+     * Actors are first looked up in the `'background'` focus area, then in `'foreground'`.
+     * New actors are always created in the current focus area.
+     *
+     * @param name - Case-sensitive name of the Actor, e.g. `Alice`
+     * @returns The actor with the given name
+     */
+    public actor(name: string): Actor {
+        if (! this.existingActorCalled(name)) {
+            const actor = this.prepareActor(new Actor(name, this.stage, [
+                new RaiseErrors(this.stage),
+                new ScheduleWork(this.clock, this.interactionTimeout)
+            ]));
+
+            this.actors[this.currentFocusValue].set(actor.name, actor);
+
+            this.stage.announce(
+                new ActorEntersStage(
+                    this.stage.currentSceneId(),
+                    actor.toJSON(),
+                    this.stage.currentTime(),
+                )
+            );
+        }
+
+        const previousActorInSpotlight = this.currentActor;
+        const previousSceneOfSpotlightedActor = this.currentActorScene;
+
+        this.currentActor = this.existingActorCalled(name);
+        this.currentActorScene = this.stage.currentSceneId();
+
+        const spotlightShifted = this.currentActor !== previousActorInSpotlight
+            || ! this.stage.currentSceneId().equals(previousSceneOfSpotlightedActor);
+
+        if (spotlightShifted) {
+            this.stage.announce(
+                new ActorSpotlighted(
+                    this.stage.currentSceneId(),
+                    this.currentActor.toJSON(),
+                    this.stage.currentTime(),
+                )
+            );
+        }
+
+        return this.currentActor;
+    }
+
+    private prepareActor(actor: Actor): Actor {
+
+        let preparedActor: Actor;
+
+        try {
+            preparedActor = this.cast.prepare(actor);
+        }
+        catch (error) {
+            throw new ConfigurationError(`${ this.typeOf(this.cast) } encountered a problem when preparing actor "${ actor.name }" for stage`, error);
+        }
+
+        if (! (preparedActor instanceof Actor)) {
+            throw new ConfigurationError(`Instead of a new instance of actor "${ actor.name }", ${ this.typeOf(this.cast) } returned ${ preparedActor }`);
+        }
+
+        return preparedActor;
+    }
+
+    private typeOf(cast: Cast): string {
+        return cast.constructor === Object
+            ? 'Cast'
+            : cast.constructor.name;
+    }
+
+    private existingActorCalled(name: string): Actor {
+        return this.actors['background'].has(name)
+            ? this.actors['background'].get(name)
+            : this.actors['foreground'].get(name);
+    }
+
+    /**
+     * Returns `true` if there is an [`Actor`](https://serenity-js.org/api/core/class/Actor/) in the spotlight, `false` otherwise.
+     *
+     * @returns `true` if an actor is currently spotlighted
+     */
+    public hasActorInTheSpotlight(): boolean {
+        return Boolean(this.currentActor);
+    }
+
+    /**
+     * Returns the last [`Actor`](https://serenity-js.org/api/core/class/Actor/) instantiated
+     * via [`actor`](https://serenity-js.org/api/core/class/ActorLifecycleManager/#actor).
+     *
+     * @returns The currently spotlighted actor
+     *
+     * @throws [`LogicError`](https://serenity-js.org/api/core/class/LogicError/)
+     *  If no [`Actor`](https://serenity-js.org/api/core/class/Actor/) has been activated yet
+     */
+    public actorInTheSpotlight(): Actor {
+        if (! this.currentActor) {
+            throw new LogicError(`There is no actor in the spotlight yet. Make sure you instantiate one with stage.actor(actorName) before calling this method.`);
+        }
+
+        return this.currentActor;
+    }
+
+    /**
+     * Switches the focus to the specified stage area.
+     *
+     * Actors created after this call will be added to the specified area.
+     * This method is typically called automatically by the [`Stage`](https://serenity-js.org/api/core/class/Stage/)
+     * in response to [`SceneStarts`](https://serenity-js.org/api/core-events/class/SceneStarts/) and
+     * [`SceneFinishes`](https://serenity-js.org/api/core-events/class/SceneFinishes/) events.
+     *
+     * Test runner adapters can also call this method directly to control actor lifecycle
+     * when scene events are not available (e.g., in Playwright Test where the reporter
+     * runs in a separate process).
+     *
+     * @param focus - The focus area to switch to: `'foreground'` for scene-scoped actors,
+     *                `'background'` for test run-scoped actors
+     */
+    switchFocus(focus: StageFocus): void {
+        this.currentFocusValue = focus;
+    }
+
+    /**
+     * Returns the current focus area.
+     *
+     * @returns The current focus: `'foreground'` or `'background'`
+     */
+    currentFocus(): StageFocus {
+        return this.currentFocusValue;
+    }
+
+    /**
+     * Returns all actors in the specified focus area.
+     *
+     * This method is used by the [`Stage`](https://serenity-js.org/api/core/class/Stage/) to retrieve
+     * actors for dismissal when scenes or test runs finish.
+     *
+     * @param focus - The focus area to retrieve actors from
+     * @returns An array of actors in the specified focus area
+     */
+    actorsIn(focus: StageFocus): Actor[] {
+        return Array.from(this.actors[focus].values());
+    }
+
+    /**
+     * Clears the spotlight if the current actor is in the specified focus area.
+     *
+     * This ensures that after actors in a focus area are dismissed, the spotlight
+     * doesn't reference a dismissed actor.
+     *
+     * @param focus - The focus area to check
+     */
+    clearSpotlightIfIn(focus: StageFocus): void {
+
+        const actors = this.actorsIn(focus);
+
+        if (actors.includes(this.currentActor)) {
+            this.currentActor = undefined;
+        }
+    }
+
+    /**
+     * Clears all actors from the specified focus area.
+     *
+     * This method is called by the [`Stage`](https://serenity-js.org/api/core/class/Stage/) after
+     * actors have been dismissed to remove them from the internal tracking maps.
+     *
+     * @param focus - The focus area to clear
+     */
+    clearActorsIn(focus: StageFocus): void {
+        this.actors[focus].clear();
+    }
+}

package/src/stage/Stage.ts

@@ -1,17 +1,13 @@
-import { ensure, isDefined, property } from 'tiny-types';
+import { ensure, isDefined } from 'tiny-types';
 
 import type { SerenityConfig } from '../config/index.js';
 import {
-    ConfigurationError,
     ErrorFactory,
     type ErrorOptions,
     LogicError,
-    RaiseErrors,
     type RuntimeError
 } from '../errors/index.js';
 import {
-    ActorEntersStage,
-    ActorSpotlighted,
     ActorStageExitAttempted,
     ActorStageExitCompleted,
     ActorStageExitFailed,
@@ -23,9 +19,11 @@ import {
     TestRunFinishes
 } from '../events/index.js';
 import { type ActivityDetails, CorrelationId, type CorrelationIdFactory, Name } from '../model/index.js';
-import { Actor, type Clock, type Duration, ScheduleWork, type Timestamp } from '../screenplay/index.js';
-import type { ListensToDomainEvents } from '../stage/index.js';
+import type { Actor} from '../screenplay/index.js';
+import type { Clock, Duration, Timestamp } from '../screenplay/index.js';
+import { ActorLifecycleManager, type StageFocus } from './ActorLifecycleManager.js';
 import type { Cast } from './Cast.js';
+import type { ListensToDomainEvents } from './ListensToDomainEvents.js';
 import type { StageManager } from './StageManager.js';
 
 /**
@@ -48,50 +46,33 @@ export class Stage implements EmitsDomainEvents {
 
     public static readonly unknownSceneId = new CorrelationId('unknown')
 
-    /**
-     * Actors instantiated after the scene has started,
-     * who will be dismissed when the scene finishes.
-     */
-    private actorsOnFrontStage: Map<string, Actor> = new Map<string, Actor>();
-
-    /**
-     * Actors instantiated before the scene has started,
-     * who will be dismissed when the test run finishes.
-     */
-    private actorsOnBackstage: Map<string, Actor> = new Map<string, Actor>();
-
-    private actorsOnStage: Map<string, Actor> = this.actorsOnBackstage;
-
-    /**
-     * The most recent actor referenced via the [`Actor`](https://serenity-js.org/api/core/class/Actor/) method
-     */
-    private actorInTheSpotlight: Actor = undefined;
-
-    /**
-     * The scene in which the spotlight was last set.
-     * Used to detect when the spotlight shifts to a different scene context.
-     */
-    private sceneOfSpotlightedActor: CorrelationId = undefined;
-
     private currentActivity: { id: CorrelationId, details: ActivityDetails } = undefined;
 
     private currentScene: CorrelationId = Stage.unknownSceneId;
 
+    private readonly actorLifecycleManager: ActorLifecycleManager
+
     /**
-     * @param cast
-     * @param manager
-     * @param errors
-     * @param clock
-     * @param interactionTimeout
-     * @param sceneIdFactory
+     * Creates a new Stage instance.
+     *
+     * @param cast - The default cast to use for preparing actors
+     * @param manager - The stage manager responsible for notifying listeners of domain events
+     * @param errors - Factory for creating runtime errors with proper context
+     * @param clock - Clock used for timestamping domain events
+     * @param interactionTimeout - Default timeout for actor interactions
+     * @param sceneIdFactory - Factory for creating scene correlation IDs
+     * @param actorLifecycleManager - Optional custom ActorLifecycleManager instance.
+     *        When provided, allows test runner adapters to control actor lifecycle programmatically.
+     *        If not provided, a default manager is created.
      */
     constructor(
-        private cast: Cast,
-        private manager: StageManager,
+        cast: Cast,
+        private readonly manager: StageManager,
         private errors: ErrorFactory,
         private readonly clock: Clock,
-        private interactionTimeout: Duration,
+        interactionTimeout: Duration,
         private readonly sceneIdFactory: CorrelationIdFactory = CorrelationId,
+        actorLifecycleManager?: ActorLifecycleManager,
     ) {
         ensure('Cast', cast, isDefined());
         ensure('StageManager', manager, isDefined());
@@ -99,13 +80,18 @@ export class Stage implements EmitsDomainEvents {
         ensure('Clock', clock, isDefined());
         ensure('interactionTimeout', interactionTimeout, isDefined());
         ensure('sceneIdFactory', sceneIdFactory, isDefined());
+
+        this.actorLifecycleManager = actorLifecycleManager ?? new ActorLifecycleManager(cast, this.clock, interactionTimeout);
+        this.actorLifecycleManager.assignTo(this);
     }
 
     configure(options: Pick<SerenityConfig, 'actors' | 'cueTimeout' | 'interactionTimeout' | 'diffFormatter'>): void {
-        this.interactionTimeout = options.interactionTimeout || this.interactionTimeout;
+        if (options.interactionTimeout) {
+            this.actorLifecycleManager.configure({ interactionTimeout: options.interactionTimeout });
+        }
 
         if (options.actors) {
-            this.engage(options.actors);
+            this.actorLifecycleManager.engage(options.actors);
         }
 
         if (options.cueTimeout) {
@@ -134,52 +120,7 @@ export class Stage implements EmitsDomainEvents {
      *  Case-sensitive name of the Actor, e.g. `Alice`
      */
     actor(name: string): Actor {
-        if (! this.instantiatedActorCalled(name)) {
-            let actor;
-            try {
-                const newActor = new Actor(name, this, [
-                    new RaiseErrors(this),
-                    new ScheduleWork(this.clock, this.interactionTimeout)
-                ]);
-
-                actor = this.cast.prepare(newActor);
-            }
-            catch (error) {
-                throw new ConfigurationError(`${ this.typeOf(this.cast) } encountered a problem when preparing actor "${ name }" for stage`, error);
-            }
-
-            if (! (actor instanceof Actor)) {
-                throw new ConfigurationError(`Instead of a new instance of actor "${ name }", ${ this.typeOf(this.cast) } returned ${ actor }`);
-            }
-
-            this.actorsOnStage.set(name, actor);
-
-            this.announce(
-                new ActorEntersStage(
-                    this.currentScene,
-                    actor.toJSON(),
-                )
-            )
-        }
-
-        const previousActorInSpotlight = this.actorInTheSpotlight;
-        const previousSceneOfSpotlightedActor = this.sceneOfSpotlightedActor;
-        this.actorInTheSpotlight = this.instantiatedActorCalled(name);
-        this.sceneOfSpotlightedActor = this.currentScene;
-
-        const spotlightShifted = this.actorInTheSpotlight !== previousActorInSpotlight
-            || ! this.currentScene.equals(previousSceneOfSpotlightedActor);
-
-        if (spotlightShifted) {
-            this.announce(
-                new ActorSpotlighted(
-                    this.currentScene,
-                    this.actorInTheSpotlight.toJSON(),
-                )
-            );
-        }
-
-        return this.actorInTheSpotlight;
+        return this.actorLifecycleManager.actor(name);
     }
 
     /**
@@ -190,18 +131,14 @@ export class Stage implements EmitsDomainEvents {
      *  If no [`Actor`](https://serenity-js.org/api/core/class/Actor/) has been activated yet
      */
     theActorInTheSpotlight(): Actor {
-        if (! this.actorInTheSpotlight) {
-            throw new LogicError(`There is no actor in the spotlight yet. Make sure you instantiate one with stage.actor(actorName) before calling this method.`);
-        }
-
-        return this.actorInTheSpotlight;
+        return this.actorLifecycleManager.actorInTheSpotlight();
     }
 
     /**
      * Returns `true` if there is an [`Actor`](https://serenity-js.org/api/core/class/Actor/) in the spotlight, `false` otherwise.
      */
     theShowHasStarted(): boolean {
-        return !! this.actorInTheSpotlight;
+        return this.actorLifecycleManager.hasActorInTheSpotlight();
     }
 
     /**
@@ -211,12 +148,12 @@ export class Stage implements EmitsDomainEvents {
      * @param actors
      */
     engage(actors: Cast): void {
-        this.cast = ensure('actors', actors, isDefined(), property('prepare', isDefined()));
+        this.actorLifecycleManager.engage(actors);
     }
 
     /**
      * Assigns listeners to be notified of [Serenity/JS domain events](https://serenity-js.org/api/core-events/class/DomainEvent/)
-     * emitted via [`Stage.announce`](https://serenity-js.org/api/core/class/Stage/#announce).s
+     * emitted via [`Stage.announce`](https://serenity-js.org/api/core/class/Stage/#announce).
      *
      * @param listeners
      */
@@ -238,24 +175,70 @@ export class Stage implements EmitsDomainEvents {
 
     private announceSingle(event: DomainEvent): void {
         if (event instanceof SceneStarts) {
-            this.actorsOnStage = this.actorsOnFrontStage;
+            this.actorLifecycleManager.switchFocus('foreground');
         }
 
         if (event instanceof SceneFinishes || event instanceof TestRunFinishes) {
-            this.notifyOfStageExit(this.currentSceneId());
+            this.notifyOfStageExit(this.actorLifecycleManager.currentFocus());
         }
 
         this.manager.notifyOf(event);
 
         if (event instanceof SceneFinishes) {
-            this.dismiss(this.actorsOnStage);
-
-            this.actorsOnStage = this.actorsOnBackstage;
+            this.dismissActorsIn('foreground');
+            this.actorLifecycleManager.switchFocus('background');
         }
 
         if (event instanceof TestRunFinishes) {
-            this.dismiss(this.actorsOnStage);
+            this.dismissActorsIn('background');
+        }
+    }
+
+    private notifyOfStageExit(focus: StageFocus): void {
+        for (const actor of this.actorLifecycleManager.actorsIn(focus)) {
+            this.announce(new ActorStageExitStarts(
+                this.currentSceneId(),
+                actor.toJSON(),
+                this.currentTime(),
+            ));
+        }
+    }
+
+    private async dismissActorsIn(focus: StageFocus): Promise<void> {
+        const actors = this.actorLifecycleManager.actorsIn(focus);
+
+        this.actorLifecycleManager.clearSpotlightIfIn(focus);
+
+        // Wait for the Photographer to finish taking any screenshots
+        await this.manager.waitForAsyncOperationsToComplete();
+
+        const actorsToDismiss = new Map<Actor, CorrelationId>(actors.map(actor => [ actor, CorrelationId.create() ]));
+
+        for (const [ actor, correlationId ] of actorsToDismiss) {
+            this.announce(new ActorStageExitAttempted(
+                correlationId,
+                new Name(actor.name),
+                this.currentTime(),
+            ));
+        }
+
+        // Try to dismiss each actor
+        for (const [ actor, correlationId ] of actorsToDismiss) {
+            try {
+                await actor.dismiss();
+
+                this.announce(new ActorStageExitCompleted(correlationId, new Name(actor.name), this.currentTime()));
+            }
+            catch (error) {
+                this.announce(new ActorStageExitFailed(
+                    error,
+                    correlationId,
+                    this.currentTime()
+                ));
+            }
         }
+
+        this.actorLifecycleManager.clearActorsIn(focus);
     }
 
     /**
@@ -263,7 +246,7 @@ export class Stage implements EmitsDomainEvents {
      * [`DomainEvent`](https://serenity-js.org/api/core-events/class/DomainEvent/) objects are instantiated by you programmatically.
      */
     currentTime(): Timestamp {
-        return this.manager.currentTime();
+        return this.clock.now();
     }
 
     /**
@@ -343,65 +326,4 @@ export class Stage implements EmitsDomainEvents {
             ...options,
         });
     }
-
-    private instantiatedActorCalled(name: string): Actor | undefined {
-        return this.actorsOnBackstage.has(name)
-            ? this.actorsOnBackstage.get(name)
-            : this.actorsOnFrontStage.get(name)
-    }
-
-    private notifyOfStageExit(sceneId: CorrelationId): void {
-        for (const actor of this.actorsOnStage.values()) {
-            this.announce(new ActorStageExitStarts(
-                sceneId,
-                actor.toJSON(),
-                this.currentTime(),
-            ));
-        }
-    }
-
-    private async dismiss(activeActors: Map<string, Actor>): Promise<void> {
-        const actors = Array.from(activeActors.values());
-
-        if (actors.includes(this.actorInTheSpotlight)) {
-            this.actorInTheSpotlight = undefined;
-        }
-
-        // Wait for the Photographer to finish taking any screenshots
-        await this.manager.waitForAsyncOperationsToComplete();
-
-        const actorsToDismiss = new Map<Actor, CorrelationId>(actors.map(actor => [actor, CorrelationId.create()]));
-
-        for (const [ actor, correlationId ] of actorsToDismiss) {
-            this.announce(new ActorStageExitAttempted(
-                correlationId,
-                new Name(actor.name),
-                this.currentTime(),
-            ));
-        }
-
-        // Try to dismiss each actor
-        for (const [ actor, correlationId ] of actorsToDismiss) {
-            try {
-                await actor.dismiss();
-
-                this.announce(new ActorStageExitCompleted(correlationId, new Name(actor.name), this.currentTime()));
-            }
-            catch (error) {
-                this.announce(new ActorStageExitFailed(
-                    error,
-                    correlationId,
-                    this.currentTime()
-                ));
-            }
-        }
-
-        activeActors.clear();
-    }
-
-    private typeOf(cast: Cast): string {
-        return cast.constructor === Object
-            ? 'Cast'
-            : cast.constructor.name;
-    }
 }