@valkyrjaio/valkyrja 26.1.0 → 26.2.0

package/README.md

@@ -15,7 +15,7 @@ does the heavy lifting so you can focus on your application.
 <p>
     <a href="https://www.npmjs.com/package/@valkyrjaio/valkyrja"><img src="https://img.shields.io/npm/v/@valkyrjaio/valkyrja.svg" alt="Latest Version on npm"></a>
     <a href="https://www.npmjs.com/package/@valkyrjaio/valkyrja"><img src="https://img.shields.io/node/v/@valkyrjaio/valkyrja.svg" alt="Supported Node.js Version"></a>
-    <a href="https://www.npmjs.com/package/@valkyrjaio/valkyrja"><img src="https://img.shields.io/npm/l/@valkyrjaio/valkyrja.svg" alt="License"></a>
+    <a href="https://github.com/valkyrjaio/valkyrja-ts/blob/26.x/LICENSE.md"><img src="https://img.shields.io/github/license/valkyrjaio/valkyrja-ts.svg" alt="License"></a>
     <a href="https://github.com/valkyrjaio/valkyrja-ts/actions/workflows/ci.yml?query=branch%3A26.x"><img src="https://github.com/valkyrjaio/valkyrja-ts/actions/workflows/ci.yml/badge.svg?branch=26.x" alt="CI Status"></a>
 </p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyrjaio/valkyrja",
-    "version": "26.1.0",
+    "version": "26.2.0",
     "description": "The Valkyrja Framework.",
     "keywords": [
         "framework",

package/src/Valkyrja/Application/Constant/ApplicationInfo.ts

@@ -8,8 +8,8 @@
  */
 
 export class ApplicationInfo {
-    static readonly VERSION = '26.1.0' as const;
-    static readonly VERSION_BUILD_DATE_TIME = 'June 17 2026 19:35:02 MST' as const;
+    static readonly VERSION = '26.2.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'July 24 2026 23:49:19 MST' as const;
     static readonly ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _

package/src/Valkyrja/Application/Data/CliConfig.ts

@@ -46,6 +46,6 @@ export class CliConfig implements CliConfigContract {
             CliServerServiceId.LogThrowableCaughtMiddleware,
             CliServerServiceId.OutputThrowableCaughtMiddleware,
         ],
-        public readonly exitedMiddleware: string[] = [],
+        public readonly processExitingMiddleware: string[] = [],
     ) {}
 }

package/src/Valkyrja/Application/Data/Contract/CliConfigContract.ts

@@ -17,7 +17,7 @@ export interface CliConfigContract extends ConfigContract {
     readonly routeNotMatchedMiddleware: string[];
     readonly routeDispatchedMiddleware: string[];
     readonly throwableCaughtMiddleware: string[];
-    readonly exitedMiddleware: string[];
+    readonly processExitingMiddleware: string[];
 }
 
 export namespace CliConfigContract {

package/src/Valkyrja/Application/Data/Contract/HttpConfigContract.ts

@@ -16,7 +16,7 @@ export interface HttpConfigContract extends ConfigContract {
     readonly routeDispatchedMiddleware: string[];
     readonly throwableCaughtMiddleware: string[];
     readonly sendingResponseMiddleware: string[];
-    readonly terminatedMiddleware: string[];
+    readonly responseSentMiddleware: string[];
 }
 
 export namespace HttpConfigContract {

package/src/Valkyrja/Application/Data/HttpConfig.ts

@@ -36,6 +36,6 @@ export class HttpConfig implements HttpConfigContract {
         public readonly routeDispatchedMiddleware: string[] = [],
         public readonly throwableCaughtMiddleware: string[] = [],
         public readonly sendingResponseMiddleware: string[] = [],
-        public readonly terminatedMiddleware: string[] = [],
+        public readonly responseSentMiddleware: string[] = [],
     ) {}
 }

package/src/Valkyrja/Cli/Interaction/Enum/BackgroundColor.ts

@@ -26,8 +26,6 @@ export enum BackgroundColor {
     LIGHT_WHITE = 107,
 }
 
-export namespace BackgroundColor {
-    export function getDefault(): number {
-        return 49;
-    }
+export function backgroundColorDefault(): number {
+    return 49;
 }

package/src/Valkyrja/Cli/Interaction/Enum/Style.ts

@@ -15,19 +15,17 @@ export enum Style {
     CONCEAL = 8,
 }
 
-export namespace Style {
-    export function getDefault(style: Style): number {
-        switch (style) {
-            case Style.BOLD:
-                return 22;
-            case Style.UNDERSCORE:
-                return 24;
-            case Style.BLINK:
-                return 25;
-            case Style.INVERSE:
-                return 27;
-            case Style.CONCEAL:
-                return 28;
-        }
+export function styleDefault(style: Style): number {
+    switch (style) {
+        case Style.BOLD:
+            return 22;
+        case Style.UNDERSCORE:
+            return 24;
+        case Style.BLINK:
+            return 25;
+        case Style.INVERSE:
+            return 27;
+        case Style.CONCEAL:
+            return 28;
     }
 }

package/src/Valkyrja/Cli/Interaction/Enum/TextColor.ts

@@ -26,8 +26,6 @@ export enum TextColor {
     LIGHT_WHITE = 97,
 }
 
-export namespace TextColor {
-    export function getDefault(): number {
-        return 39;
-    }
+export function textColorDefault(): number {
+    return 39;
 }

package/src/Valkyrja/Cli/Interaction/Format/BackgroundColorFormat.ts

@@ -7,11 +7,11 @@
  * file that was distributed with this source code.
  */
 
-import { BackgroundColor } from '../Enum/BackgroundColor.ts';
+import { BackgroundColor, backgroundColorDefault } from '../Enum/BackgroundColor.ts';
 import { Format } from './Format.ts';
 
 export class BackgroundColorFormat extends Format {
     constructor(backgroundColor: BackgroundColor) {
-        super(String(backgroundColor), String(BackgroundColor.getDefault()));
+        super(String(backgroundColor), String(backgroundColorDefault()));
     }
 }

package/src/Valkyrja/Cli/Interaction/Format/StyleFormat.ts

@@ -7,11 +7,11 @@
  * file that was distributed with this source code.
  */
 
-import { Style } from '../Enum/Style.ts';
+import { Style, styleDefault } from '../Enum/Style.ts';
 import { Format } from './Format.ts';
 
 export class StyleFormat extends Format {
     constructor(style: Style) {
-        super(String(style), String(Style.getDefault(style)));
+        super(String(style), String(styleDefault(style)));
     }
 }

package/src/Valkyrja/Cli/Interaction/Format/TextColorFormat.ts

@@ -7,11 +7,11 @@
  * file that was distributed with this source code.
  */
 
-import { TextColor } from '../Enum/TextColor.ts';
+import { TextColor, textColorDefault } from '../Enum/TextColor.ts';
 import { Format } from './Format.ts';
 
 export class TextColorFormat extends Format {
     constructor(textColor: TextColor) {
-        super(String(textColor), String(TextColor.getDefault()));
+        super(String(textColor), String(textColorDefault()));
     }
 }

package/src/Valkyrja/Cli/Interaction/Option/Factory/OptionFactory.ts

@@ -18,9 +18,12 @@ export abstract class OptionFactory {
         OptionFactory.validateArgIsOption(arg);
 
         const type = OptionFactory.getOptionType(arg);
-        const parts = arg.split('=');
-        const name = (parts[0] ?? '').replace(/^-+/, '').trim();
-        const value = parts[1] ?? '';
+        // The name is everything before the first '='; the value is the segment after it (if any).
+        const name = arg
+            .replace(/=[\s\S]*$/, '')
+            .replace(/^-+/, '')
+            .trim();
+        const value = arg.split('=')[1] ?? '';
 
         OptionFactory.validateNonEmptyName(name);
 

package/src/Valkyrja/Cli/Middleware/Constant/CliMiddlewareServiceId.ts

@@ -18,5 +18,6 @@ export class CliMiddlewareServiceId {
         'Valkyrja.Cli.Middleware.Handler.RouteDispatchedHandlerContract' as const;
     static readonly ThrowableCaughtHandlerContract =
         'Valkyrja.Cli.Middleware.Handler.ThrowableCaughtHandlerContract' as const;
-    static readonly ExitedHandlerContract = 'Valkyrja.Cli.Middleware.Handler.ExitedHandlerContract' as const;
+    static readonly ProcessExitingHandlerContract =
+        'Valkyrja.Cli.Middleware.Handler.ProcessExitingHandlerContract' as const;
 }

package/src/Valkyrja/Cli/Middleware/Contract/ProcessExitingMiddlewareContract.ts

@@ -0,0 +1,22 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.ts';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.ts';
+import type { ProcessExitingHandlerContract } from '../Handler/Contract/ProcessExitingHandlerContract.ts';
+
+export interface ProcessExitingMiddlewareContract {
+    processExiting(input: InputContract, output: OutputContract, handler: ProcessExitingHandlerContract): void;
+}
+
+export namespace ProcessExitingMiddlewareContract {
+    export function instanceOf(value: unknown): value is ProcessExitingMiddlewareContract {
+        return typeof value === 'object' && value !== null && 'processExiting' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/HandlerContract.ts

@@ -7,7 +7,7 @@
  * file that was distributed with this source code.
  */
 
-import type { ExitedMiddlewareContract } from '../../Contract/ExitedMiddlewareContract.ts';
+import type { ProcessExitingMiddlewareContract } from '../../Contract/ProcessExitingMiddlewareContract.ts';
 import type { InputReceivedMiddlewareContract } from '../../Contract/InputReceivedMiddlewareContract.ts';
 import type { RouteDispatchedMiddlewareContract } from '../../Contract/RouteDispatchedMiddlewareContract.ts';
 import type { RouteMatchedMiddlewareContract } from '../../Contract/RouteMatchedMiddlewareContract.ts';
@@ -20,7 +20,7 @@ export type AnyMiddlewareContract =
     | RouteNotMatchedMiddlewareContract
     | RouteDispatchedMiddlewareContract
     | ThrowableCaughtMiddlewareContract
-    | ExitedMiddlewareContract;
+    | ProcessExitingMiddlewareContract;
 
 export interface HandlerContract {
     add(...middleware: string[]): void;

package/src/Valkyrja/Cli/Middleware/Handler/Contract/{ExitedHandlerContract.ts → ProcessExitingHandlerContract.ts}

@@ -11,12 +11,12 @@ import type { InputContract } from '../../../Interaction/Input/Contract/InputCon
 import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.ts';
 import type { HandlerContract } from './HandlerContract.ts';
 
-export interface ExitedHandlerContract extends HandlerContract {
-    exited(input: InputContract, output: OutputContract): void;
+export interface ProcessExitingHandlerContract extends HandlerContract {
+    processExiting(input: InputContract, output: OutputContract): void;
 }
 
-export namespace ExitedHandlerContract {
-    export function instanceOf(value: unknown): value is ExitedHandlerContract {
-        return typeof value === 'object' && value !== null && 'exited' in value;
+export namespace ProcessExitingHandlerContract {
+    export function instanceOf(value: unknown): value is ProcessExitingHandlerContract {
+        return typeof value === 'object' && value !== null && 'processExiting' in value;
     }
 }

package/src/Valkyrja/Cli/Middleware/Handler/{ExitedHandler.ts → ProcessExitingHandler.ts}

@@ -9,16 +9,16 @@
 
 import type { InputContract } from '../../Interaction/Input/Contract/InputContract.ts';
 import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.ts';
-import type { ExitedMiddlewareContract } from '../Contract/ExitedMiddlewareContract.ts';
+import type { ProcessExitingMiddlewareContract } from '../Contract/ProcessExitingMiddlewareContract.ts';
 import { Handler } from './Abstract/Handler.ts';
-import type { ExitedHandlerContract } from './Contract/ExitedHandlerContract.ts';
+import type { ProcessExitingHandlerContract } from './Contract/ProcessExitingHandlerContract.ts';
 
-export class ExitedHandler extends Handler implements ExitedHandlerContract {
-    exited(input: InputContract, output: OutputContract): void {
+export class ProcessExitingHandler extends Handler implements ProcessExitingHandlerContract {
+    processExiting(input: InputContract, output: OutputContract): void {
         const next = this.next;
 
         if (next !== null) {
-            this.getMiddleware<ExitedMiddlewareContract>(next).exited(input, output, this);
+            this.getMiddleware<ProcessExitingMiddlewareContract>(next).processExiting(input, output, this);
         }
     }
 }

package/src/Valkyrja/Cli/Middleware/Provider/CliMiddlewareServiceProvider.ts

@@ -12,13 +12,13 @@ import type { CliConfigContract } from '../../../Application/Data/Contract/CliCo
 import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.ts';
 import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.ts';
 import { CliMiddlewareServiceId } from '../Constant/CliMiddlewareServiceId.ts';
-import type { ExitedHandlerContract } from '../Handler/Contract/ExitedHandlerContract.ts';
+import type { ProcessExitingHandlerContract } from '../Handler/Contract/ProcessExitingHandlerContract.ts';
 import type { InputReceivedHandlerContract } from '../Handler/Contract/InputReceivedHandlerContract.ts';
 import type { RouteDispatchedHandlerContract } from '../Handler/Contract/RouteDispatchedHandlerContract.ts';
 import type { RouteMatchedHandlerContract } from '../Handler/Contract/RouteMatchedHandlerContract.ts';
 import type { RouteNotMatchedHandlerContract } from '../Handler/Contract/RouteNotMatchedHandlerContract.ts';
 import type { ThrowableCaughtHandlerContract } from '../Handler/Contract/ThrowableCaughtHandlerContract.ts';
-import { ExitedHandler } from '../Handler/ExitedHandler.ts';
+import { ProcessExitingHandler } from '../Handler/ProcessExitingHandler.ts';
 import { InputReceivedHandler } from '../Handler/InputReceivedHandler.ts';
 import { RouteDispatchedHandler } from '../Handler/RouteDispatchedHandler.ts';
 import { RouteMatchedHandler } from '../Handler/RouteMatchedHandler.ts';
@@ -38,7 +38,8 @@ export class CliMiddlewareServiceProvider implements ServiceProviderContract {
                 CliMiddlewareServiceProvider.publishRouteNotMatchedHandler,
             [CliMiddlewareServiceId.RouteDispatchedHandlerContract]:
                 CliMiddlewareServiceProvider.publishRouteDispatchedHandler,
-            [CliMiddlewareServiceId.ExitedHandlerContract]: CliMiddlewareServiceProvider.publishExitedHandler,
+            [CliMiddlewareServiceId.ProcessExitingHandlerContract]:
+                CliMiddlewareServiceProvider.publishProcessExitingHandler,
         };
     }
 
@@ -107,13 +108,16 @@ export class CliMiddlewareServiceProvider implements ServiceProviderContract {
         handler.add(...config.routeNotMatchedMiddleware);
     }
 
-    static publishExitedHandler(this: void, container: ContainerContract): void {
+    static publishProcessExitingHandler(this: void, container: ContainerContract): void {
         const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
 
-        const handler = new ExitedHandler(container);
+        const handler = new ProcessExitingHandler(container);
 
-        container.setSingleton<ExitedHandlerContract>(CliMiddlewareServiceId.ExitedHandlerContract, handler);
+        container.setSingleton<ProcessExitingHandlerContract>(
+            CliMiddlewareServiceId.ProcessExitingHandlerContract,
+            handler,
+        );
 
-        handler.add(...config.exitedMiddleware);
+        handler.add(...config.processExitingMiddleware);
     }
 }

package/src/Valkyrja/Cli/Routing/Data/Contract/RouteContract.ts

@@ -43,9 +43,9 @@ export interface RouteContract {
     getThrowableCaughtMiddleware(): string[];
     withThrowableCaughtMiddleware(...middleware: string[]): this;
     withAddedThrowableCaughtMiddleware(...middleware: string[]): this;
-    getExitedMiddleware(): string[];
-    withExitedMiddleware(...middleware: string[]): this;
-    withAddedExitedMiddleware(...middleware: string[]): this;
+    getProcessExitingMiddleware(): string[];
+    withProcessExitingMiddleware(...middleware: string[]): this;
+    withAddedProcessExitingMiddleware(...middleware: string[]): this;
     getHandler(): (container: ContainerContract, route: RouteContract) => OutputContract;
     withHandler(handler: (container: ContainerContract, route: RouteContract) => OutputContract): this;
 }

package/src/Valkyrja/Cli/Routing/Data/Route.ts

@@ -27,7 +27,7 @@ export class Route implements RouteContract {
         protected routeMatchedMiddleware: string[] = [],
         protected routeDispatchedMiddleware: string[] = [],
         protected throwableCaughtMiddleware: string[] = [],
-        protected exitedMiddleware: string[] = [],
+        protected processExitingMiddleware: string[] = [],
         protected arguments_: ArgumentParameterContract[] = [],
         protected options: OptionParameterContract[] = [],
     ) {}
@@ -183,19 +183,19 @@ export class Route implements RouteContract {
         return clone;
     }
 
-    getExitedMiddleware(): string[] {
-        return this.exitedMiddleware;
+    getProcessExitingMiddleware(): string[] {
+        return this.processExitingMiddleware;
     }
 
-    withExitedMiddleware(...middleware: string[]): this {
+    withProcessExitingMiddleware(...middleware: string[]): this {
         const clone = ObjectFactory.clone(this);
-        clone.exitedMiddleware = middleware;
+        clone.processExitingMiddleware = middleware;
         return clone;
     }
 
-    withAddedExitedMiddleware(...middleware: string[]): this {
+    withAddedProcessExitingMiddleware(...middleware: string[]): this {
         const clone = ObjectFactory.clone(this);
-        clone.exitedMiddleware = [...this.exitedMiddleware, ...middleware];
+        clone.processExitingMiddleware = [...this.processExitingMiddleware, ...middleware];
         return clone;
     }
 

package/src/Valkyrja/Cli/Routing/Dispatcher/Router.ts

@@ -15,8 +15,8 @@ import { ErrorMessage } from '../../Interaction/Message/ErrorMessage.ts';
 import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.ts';
 import { OutputFactory } from '../../Interaction/Output/Factory/OutputFactory.ts';
 import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
-import { ExitedHandler } from '../../Middleware/Handler/ExitedHandler.ts';
-import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.ts';
+import { ProcessExitingHandler } from '../../Middleware/Handler/ProcessExitingHandler.ts';
+import type { ProcessExitingHandlerContract } from '../../Middleware/Handler/Contract/ProcessExitingHandlerContract.ts';
 import { RouteDispatchedHandler } from '../../Middleware/Handler/RouteDispatchedHandler.ts';
 import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.ts';
 import { RouteMatchedHandler } from '../../Middleware/Handler/RouteMatchedHandler.ts';
@@ -44,7 +44,7 @@ export class Router implements RouterContract {
         protected routeMatchedHandler: RouteMatchedHandlerContract = new RouteMatchedHandler(),
         protected routeNotMatchedHandler: RouteNotMatchedHandlerContract = new RouteNotMatchedHandler(),
         protected routeDispatchedHandler: RouteDispatchedHandlerContract = new RouteDispatchedHandler(),
-        protected exitedHandler: ExitedHandlerContract = new ExitedHandler(),
+        protected processExitingHandler: ProcessExitingHandlerContract = new ProcessExitingHandler(),
     ) {}
 
     dispatch(input: InputContract): OutputContract {
@@ -99,13 +99,7 @@ export class Router implements RouterContract {
         const argumentParameters = route.getArguments();
         const updatedParams: ArgumentParameterContract[] = [];
 
-        for (let i = 0; i < argumentParameters.length; i++) {
-            const param = argumentParameters[i];
-
-            if (param === undefined) {
-                continue;
-            }
-
+        for (const [i, param] of argumentParameters.entries()) {
             let paramArguments: typeof arguments_ = [];
 
             if (param.getValueMode() === ArgumentValueMode.ARRAY) {
@@ -144,7 +138,7 @@ export class Router implements RouterContract {
         this.routeMatchedHandler.add(...route.getRouteMatchedMiddleware());
         this.routeDispatchedHandler.add(...route.getRouteDispatchedMiddleware());
         this.throwableCaughtHandler.add(...route.getThrowableCaughtMiddleware());
-        this.exitedHandler.add(...route.getExitedMiddleware());
+        this.processExitingHandler.add(...route.getProcessExitingMiddleware());
 
         this.container.setSingleton<RouteContract>(CliRoutingServiceId.RouteContract, route);
     }

package/src/Valkyrja/Cli/Routing/Provider/CliRoutingServiceProvider.ts

@@ -14,7 +14,7 @@ import type { ServiceProviderContract } from '../../../Container/Provider/Contra
 import { CliInteractionServiceId } from '../../Interaction/Constant/CliInteractionServiceId.ts';
 import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
 import { CliMiddlewareServiceId } from '../../Middleware/Constant/CliMiddlewareServiceId.ts';
-import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.ts';
+import type { ProcessExitingHandlerContract } from '../../Middleware/Handler/Contract/ProcessExitingHandlerContract.ts';
 import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteDispatchedHandlerContract.ts';
 import type { RouteMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteMatchedHandlerContract.ts';
 import type { RouteNotMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.ts';
@@ -52,7 +52,9 @@ export class CliRoutingServiceProvider implements ServiceProviderContract {
                 container.getSingleton<RouteDispatchedHandlerContract>(
                     CliMiddlewareServiceId.RouteDispatchedHandlerContract,
                 ),
-                container.getSingleton<ExitedHandlerContract>(CliMiddlewareServiceId.ExitedHandlerContract),
+                container.getSingleton<ProcessExitingHandlerContract>(
+                    CliMiddlewareServiceId.ProcessExitingHandlerContract,
+                ),
             ),
         );
     }

package/src/Valkyrja/Cli/Server/Handler/InputHandler.ts

@@ -20,8 +20,8 @@ import { NewLine } from '../../Interaction/Message/NewLine.ts';
 import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.ts';
 import { OutputFactory } from '../../Interaction/Output/Factory/OutputFactory.ts';
 import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
-import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.ts';
-import { ExitedHandler } from '../../Middleware/Handler/ExitedHandler.ts';
+import type { ProcessExitingHandlerContract } from '../../Middleware/Handler/Contract/ProcessExitingHandlerContract.ts';
+import { ProcessExitingHandler } from '../../Middleware/Handler/ProcessExitingHandler.ts';
 import type { InputReceivedHandlerContract } from '../../Middleware/Handler/Contract/InputReceivedHandlerContract.ts';
 import { InputReceivedHandler } from '../../Middleware/Handler/InputReceivedHandler.ts';
 import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
@@ -38,7 +38,7 @@ export class InputHandler implements InputHandlerContract {
         protected router: RouterContract = new Router(),
         protected inputReceivedHandler: InputReceivedHandlerContract = new InputReceivedHandler(),
         protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
-        protected exitedHandler: ExitedHandlerContract = new ExitedHandler(),
+        protected processExitingHandler: ProcessExitingHandlerContract = new ProcessExitingHandler(),
         protected interactionConfig: CliInteractionConfigContract = new CliInteractionConfig(),
         protected outputFactory: OutputFactoryContract = new OutputFactory(),
     ) {}
@@ -59,7 +59,7 @@ export class InputHandler implements InputHandlerContract {
     }
 
     exit(input: InputContract, output: OutputContract): void {
-        this.exitedHandler.exited(input, output);
+        this.processExitingHandler.processExiting(input, output);
     }
 
     run(input: InputContract): void {

package/src/Valkyrja/Cli/Server/Provider/CliServerServiceProvider.ts

@@ -16,7 +16,7 @@ import { CliInteractionServiceId } from '../../Interaction/Constant/CliInteracti
 import type { CliInteractionConfigContract } from '../../Interaction/Data/Contract/CliInteractionConfigContract.ts';
 import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
 import { CliMiddlewareServiceId } from '../../Middleware/Constant/CliMiddlewareServiceId.ts';
-import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.ts';
+import type { ProcessExitingHandlerContract } from '../../Middleware/Handler/Contract/ProcessExitingHandlerContract.ts';
 import type { InputReceivedHandlerContract } from '../../Middleware/Handler/Contract/InputReceivedHandlerContract.ts';
 import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
 import type { RouteCollectionContract } from '../../Routing/Collection/Contract/RouteCollectionContract.ts';
@@ -82,7 +82,9 @@ export class CliServerServiceProvider implements ServiceProviderContract {
                 container.getSingleton<ThrowableCaughtHandlerContract>(
                     CliMiddlewareServiceId.ThrowableCaughtHandlerContract,
                 ),
-                container.getSingleton<ExitedHandlerContract>(CliMiddlewareServiceId.ExitedHandlerContract),
+                container.getSingleton<ProcessExitingHandlerContract>(
+                    CliMiddlewareServiceId.ProcessExitingHandlerContract,
+                ),
                 container.getSingleton<CliInteractionConfigContract>(
                     CliInteractionServiceId.CliInteractionConfigContract,
                 ),

package/src/Valkyrja/Http/Message/Header/Factory/CookieFactory.ts

@@ -14,11 +14,10 @@ export abstract class CookieFactory {
             /(?:^[\n]?[ \t]*|;[ ])(?<name>[!#$%&'*+\-.0-9A-Z^_`a-z|~]+)=(?<DQUOTE>"?)(?<value>[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*)(?<DQCLOSE>"?)(?=[\n]?[ \t]*$|;[ ])/g;
         let match: RegExpExecArray | null;
         while ((match = pattern.exec(cookieHeader)) !== null) {
-            const name = match.groups?.['name'] ?? '';
-            const value = match.groups?.['value'] ?? '';
-            if (name !== '') {
-                cookies[name] = decodeURIComponent(value);
-            }
+            // The pattern only matches when both named groups are present, and `name` requires at
+            // least one character, so the groups are always defined non-empty strings here.
+            const { name, value } = match.groups as Record<'name' | 'value', string>;
+            cookies[name] = decodeURIComponent(value);
         }
         return cookies;
     }

package/src/Valkyrja/Http/Message/Header/Factory/HeaderFactory.ts

@@ -34,13 +34,13 @@ export abstract class HeaderFactory {
                 const lf = value.charCodeAt(i + 1);
                 const ws = value.charCodeAt(i + 2);
                 if (lf === 10 && (ws === 9 || ws === 32)) {
-                    result += (value[i] ?? '') + (value[i + 1] ?? '');
+                    result += value.charAt(i) + value.charAt(i + 1);
                     i++;
                 }
                 continue;
             }
             if (!HeaderFactory.isInvalidValueAscii(ascii)) {
-                result += value[i] ?? '';
+                result += value.charAt(i);
             }
         }
         return result;

package/src/Valkyrja/Http/Message/Header/Header.ts

@@ -74,11 +74,17 @@ export class Header implements HeaderContract {
     }
 
     getHeaderLine(): string {
-        return this.name + ': ' + this.valuesToString();
+        return this.valuesToString();
     }
 
     toString(): string {
-        return this.getHeaderLine();
+        const values = this.valuesToString();
+
+        if (values === '') {
+            return '';
+        }
+
+        return this.name + ': ' + values;
     }
 
     protected updateValues(...values: Array<ValueContract | string>): void {

package/src/Valkyrja/Http/Message/Header/Value/Component/Component.ts

@@ -21,9 +21,9 @@ export class Component implements ComponentContract {
 
     static fromValue(value: string): Component {
         const deliminator = '=';
-        if (value.includes(deliminator)) {
-            const [token, ...rest] = value.split(deliminator);
-            return new Component(token?.trim() ?? '', rest.join(deliminator).trim());
+        const index = value.indexOf(deliminator);
+        if (index !== -1) {
+            return new Component(value.slice(0, index).trim(), value.slice(index + 1).trim());
         }
         return new Component(value.trim());
     }

package/src/Valkyrja/Http/Message/Uri/Factory/UriFactory.ts

@@ -27,7 +27,7 @@ export abstract class UriFactory {
         } catch {
             throw new HttpUriInvalidFromStringException(`Invalid uri \`${uri}\` provided`);
         }
-        const scheme = UriFactory.filterScheme(uri.startsWith('//') ? '' : parsed.protocol.replace(/:$/, '') || '');
+        const scheme = UriFactory.filterScheme(uri.startsWith('//') ? '' : parsed.protocol.replace(/:$/, ''));
         const username = parsed.username;
         const password = parsed.password;
         const host = parsed.hostname;

package/src/Valkyrja/Http/Middleware/Constant/HttpMiddlewareServiceId.ts

@@ -20,5 +20,6 @@ export class HttpMiddlewareServiceId {
         'Valkyrja.Http.Middleware.Handler.RouteDispatchedHandlerContract' as const;
     static readonly SendingResponseHandlerContract =
         'Valkyrja.Http.Middleware.Handler.SendingResponseHandlerContract' as const;
-    static readonly TerminatedHandlerContract = 'Valkyrja.Http.Middleware.Handler.TerminatedHandlerContract' as const;
+    static readonly ResponseSentHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.ResponseSentHandlerContract' as const;
 }

package/src/Valkyrja/Http/Middleware/Contract/{TerminatedMiddlewareContract.ts → ResponseSentMiddlewareContract.ts}

@@ -9,8 +9,12 @@
 
 import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.ts';
 import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.ts';
-import type { TerminatedHandlerContract } from '../Handler/Contract/TerminatedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from '../Handler/Contract/ResponseSentHandlerContract.ts';
 
-export interface TerminatedMiddlewareContract {
-    terminated(request: ServerRequestContract, response: ResponseContract, handler: TerminatedHandlerContract): void;
+export interface ResponseSentMiddlewareContract {
+    responseSent(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        handler: ResponseSentHandlerContract,
+    ): void;
 }

package/src/Valkyrja/Http/Middleware/Handler/Contract/HandlerContract.ts

@@ -12,7 +12,7 @@ import type { RouteDispatchedMiddlewareContract } from '../../Contract/RouteDisp
 import type { RouteMatchedMiddlewareContract } from '../../Contract/RouteMatchedMiddlewareContract.ts';
 import type { RouteNotMatchedMiddlewareContract } from '../../Contract/RouteNotMatchedMiddlewareContract.ts';
 import type { SendingResponseMiddlewareContract } from '../../Contract/SendingResponseMiddlewareContract.ts';
-import type { TerminatedMiddlewareContract } from '../../Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../../Contract/ResponseSentMiddlewareContract.ts';
 import type { ThrowableCaughtMiddlewareContract } from '../../Contract/ThrowableCaughtMiddlewareContract.ts';
 
 export type AnyMiddleware =
@@ -22,7 +22,7 @@ export type AnyMiddleware =
     | RouteNotMatchedMiddlewareContract
     | RouteDispatchedMiddlewareContract
     | ThrowableCaughtMiddlewareContract
-    | TerminatedMiddlewareContract;
+    | ResponseSentMiddlewareContract;
 
 export interface HandlerContract<Middleware extends AnyMiddleware = AnyMiddleware> {
     add(...middleware: Array<new (...args: unknown[]) => Middleware>): void;

package/src/Valkyrja/Http/Middleware/Handler/Contract/{TerminatedHandlerContract.ts → ResponseSentHandlerContract.ts}

@@ -9,9 +9,9 @@
 
 import type { ServerRequestContract } from '../../../Message/Request/Contract/ServerRequestContract.ts';
 import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.ts';
-import type { TerminatedMiddlewareContract } from '../../Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../../Contract/ResponseSentMiddlewareContract.ts';
 import type { HandlerContract } from './HandlerContract.ts';
 
-export interface TerminatedHandlerContract extends HandlerContract<TerminatedMiddlewareContract> {
-    terminated(request: ServerRequestContract, response: ResponseContract): void;
+export interface ResponseSentHandlerContract extends HandlerContract<ResponseSentMiddlewareContract> {
+    responseSent(request: ServerRequestContract, response: ResponseContract): void;
 }

package/src/Valkyrja/Http/Middleware/Handler/{TerminatedHandler.ts → ResponseSentHandler.ts}

@@ -9,16 +9,19 @@
 
 import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.ts';
 import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.ts';
-import type { TerminatedMiddlewareContract } from '../Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../Contract/ResponseSentMiddlewareContract.ts';
 import { Handler } from './Abstract/Handler.ts';
-import type { TerminatedHandlerContract } from './Contract/TerminatedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from './Contract/ResponseSentHandlerContract.ts';
 
-export class TerminatedHandler extends Handler<TerminatedMiddlewareContract> implements TerminatedHandlerContract {
-    terminated(request: ServerRequestContract, response: ResponseContract): void {
+export class ResponseSentHandler
+    extends Handler<ResponseSentMiddlewareContract>
+    implements ResponseSentHandlerContract
+{
+    responseSent(request: ServerRequestContract, response: ResponseContract): void {
         const next = this.next;
 
         if (next !== null) {
-            this.getMiddleware(next).terminated(request, response, this);
+            this.getMiddleware(next).responseSent(request, response, this);
         }
     }
 }

package/src/Valkyrja/Http/Routing/Data/Contract/RouteContract.ts

@@ -14,7 +14,7 @@ import type { RouteMatchedMiddlewareContract } from '../../../Middleware/Contrac
 import type { RouteDispatchedMiddlewareContract } from '../../../Middleware/Contract/RouteDispatchedMiddlewareContract.ts';
 import type { ThrowableCaughtMiddlewareContract } from '../../../Middleware/Contract/ThrowableCaughtMiddlewareContract.ts';
 import type { SendingResponseMiddlewareContract } from '../../../Middleware/Contract/SendingResponseMiddlewareContract.ts';
-import type { TerminatedMiddlewareContract } from '../../../Middleware/Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../../../Middleware/Contract/ResponseSentMiddlewareContract.ts';
 import type { RequestStructContract } from '../../../Struct/Request/Contract/RequestStructContract.ts';
 import type { ResponseStructContract } from '../../../Struct/Response/Contract/ResponseStructContract.ts';
 
@@ -57,9 +57,11 @@ export interface RouteContract {
     withAddedSendingResponseMiddleware(
         ...middleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract>
     ): this;
-    getTerminatedMiddleware(): Array<new (...args: unknown[]) => TerminatedMiddlewareContract>;
-    withTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this;
-    withAddedTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this;
+    getResponseSentMiddleware(): Array<new (...args: unknown[]) => ResponseSentMiddlewareContract>;
+    withResponseSentMiddleware(...middleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract>): this;
+    withAddedResponseSentMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract>
+    ): this;
     hasRequestStruct(): boolean;
     getRequestStruct(): RequestStructContract;
     withRequestStruct(requestStruct: RequestStructContract): this;

package/src/Valkyrja/Http/Routing/Data/DynamicRoute.ts

@@ -15,7 +15,7 @@ import type { ResponseContract } from '../../Message/Response/Contract/ResponseC
 import type { RouteDispatchedMiddlewareContract } from '../../Middleware/Contract/RouteDispatchedMiddlewareContract.ts';
 import type { RouteMatchedMiddlewareContract } from '../../Middleware/Contract/RouteMatchedMiddlewareContract.ts';
 import type { SendingResponseMiddlewareContract } from '../../Middleware/Contract/SendingResponseMiddlewareContract.ts';
-import type { TerminatedMiddlewareContract } from '../../Middleware/Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../../Middleware/Contract/ResponseSentMiddlewareContract.ts';
 import type { ThrowableCaughtMiddlewareContract } from '../../Middleware/Contract/ThrowableCaughtMiddlewareContract.ts';
 import type { RequestStructContract } from '../../Struct/Request/Contract/RequestStructContract.ts';
 import type { ResponseStructContract } from '../../Struct/Response/Contract/ResponseStructContract.ts';
@@ -36,7 +36,7 @@ export class DynamicRoute extends Route implements DynamicRouteContract {
         routeDispatchedMiddleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract> = [],
         throwableCaughtMiddleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract> = [],
         sendingResponseMiddleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract> = [],
-        terminatedMiddleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract> = [],
+        responseSentMiddleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract> = [],
         requestStruct: RequestStructContract | null = null,
         responseStruct: ResponseStructContract | null = null,
     ) {
@@ -49,7 +49,7 @@ export class DynamicRoute extends Route implements DynamicRouteContract {
             routeDispatchedMiddleware,
             throwableCaughtMiddleware,
             sendingResponseMiddleware,
-            terminatedMiddleware,
+            responseSentMiddleware,
             requestStruct,
             responseStruct,
         );

package/src/Valkyrja/Http/Routing/Data/Route.ts

@@ -16,7 +16,7 @@ import type { ResponseContract } from '../../Message/Response/Contract/ResponseC
 import type { RouteDispatchedMiddlewareContract } from '../../Middleware/Contract/RouteDispatchedMiddlewareContract.ts';
 import type { RouteMatchedMiddlewareContract } from '../../Middleware/Contract/RouteMatchedMiddlewareContract.ts';
 import type { SendingResponseMiddlewareContract } from '../../Middleware/Contract/SendingResponseMiddlewareContract.ts';
-import type { TerminatedMiddlewareContract } from '../../Middleware/Contract/TerminatedMiddlewareContract.ts';
+import type { ResponseSentMiddlewareContract } from '../../Middleware/Contract/ResponseSentMiddlewareContract.ts';
 import type { ThrowableCaughtMiddlewareContract } from '../../Middleware/Contract/ThrowableCaughtMiddlewareContract.ts';
 import type { RequestStructContract } from '../../Struct/Request/Contract/RequestStructContract.ts';
 import type { ResponseStructContract } from '../../Struct/Response/Contract/ResponseStructContract.ts';
@@ -35,7 +35,7 @@ export class Route implements RouteContract {
         protected routeDispatchedMiddleware: Array<new (...args: unknown[]) => RouteDispatchedMiddlewareContract> = [],
         protected throwableCaughtMiddleware: Array<new (...args: unknown[]) => ThrowableCaughtMiddlewareContract> = [],
         protected sendingResponseMiddleware: Array<new (...args: unknown[]) => SendingResponseMiddlewareContract> = [],
-        protected terminatedMiddleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract> = [],
+        protected responseSentMiddleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract> = [],
         protected requestStruct: RequestStructContract | null = null,
         protected responseStruct: ResponseStructContract | null = null,
     ) {
@@ -190,21 +190,21 @@ export class Route implements RouteContract {
         return clone;
     }
 
-    getTerminatedMiddleware(): Array<new (...args: unknown[]) => TerminatedMiddlewareContract> {
-        return this.terminatedMiddleware;
+    getResponseSentMiddleware(): Array<new (...args: unknown[]) => ResponseSentMiddlewareContract> {
+        return this.responseSentMiddleware;
     }
 
-    withTerminatedMiddleware(...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>): this {
+    withResponseSentMiddleware(...middleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract>): this {
         const clone = ObjectFactory.clone(this);
-        clone.terminatedMiddleware = middleware;
+        clone.responseSentMiddleware = middleware;
         return clone;
     }
 
-    withAddedTerminatedMiddleware(
-        ...middleware: Array<new (...args: unknown[]) => TerminatedMiddlewareContract>
+    withAddedResponseSentMiddleware(
+        ...middleware: Array<new (...args: unknown[]) => ResponseSentMiddlewareContract>
     ): this {
         const clone = ObjectFactory.clone(this);
-        clone.terminatedMiddleware = [...this.terminatedMiddleware, ...middleware];
+        clone.responseSentMiddleware = [...this.responseSentMiddleware, ...middleware];
         return clone;
     }
 

package/src/Valkyrja/Http/Routing/Dispatcher/Router.ts

@@ -15,7 +15,7 @@ import { RouteDispatchedHandler } from '../../Middleware/Handler/RouteDispatched
 import { RouteMatchedHandler } from '../../Middleware/Handler/RouteMatchedHandler.ts';
 import { RouteNotMatchedHandler } from '../../Middleware/Handler/RouteNotMatchedHandler.ts';
 import { SendingResponseHandler } from '../../Middleware/Handler/SendingResponseHandler.ts';
-import { TerminatedHandler } from '../../Middleware/Handler/TerminatedHandler.ts';
+import { ResponseSentHandler } from '../../Middleware/Handler/ResponseSentHandler.ts';
 import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.ts';
 import { Matcher } from '../Matcher/Matcher.ts';
 
@@ -27,7 +27,7 @@ import type { RouteDispatchedHandlerContract } from '../../Middleware/Handler/Co
 import type { RouteMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteMatchedHandlerContract.ts';
 import type { RouteNotMatchedHandlerContract } from '../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.ts';
 import type { SendingResponseHandlerContract } from '../../Middleware/Handler/Contract/SendingResponseHandlerContract.ts';
-import type { TerminatedHandlerContract } from '../../Middleware/Handler/Contract/TerminatedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from '../../Middleware/Handler/Contract/ResponseSentHandlerContract.ts';
 import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
 import type { RouteContract } from '../Data/Contract/RouteContract.ts';
 import type { MatcherContract } from '../Matcher/Contract/MatcherContract.ts';
@@ -43,7 +43,7 @@ export class Router implements RouterContract {
         protected routeNotMatchedHandler: RouteNotMatchedHandlerContract = new RouteNotMatchedHandler(),
         protected routeDispatchedHandler: RouteDispatchedHandlerContract = new RouteDispatchedHandler(),
         protected sendingResponseHandler: SendingResponseHandlerContract = new SendingResponseHandler(),
-        protected terminatedHandler: TerminatedHandlerContract = new TerminatedHandler(),
+        protected responseSentHandler: ResponseSentHandlerContract = new ResponseSentHandler(),
     ) {}
 
     dispatch(request: ServerRequestContract): ResponseContract {
@@ -95,7 +95,7 @@ export class Router implements RouterContract {
         this.routeDispatchedHandler.add(...route.getRouteDispatchedMiddleware());
         this.throwableCaughtHandler.add(...route.getThrowableCaughtMiddleware());
         this.sendingResponseHandler.add(...route.getSendingResponseMiddleware());
-        this.terminatedHandler.add(...route.getTerminatedMiddleware());
+        this.responseSentHandler.add(...route.getResponseSentMiddleware());
 
         this.container.setSingleton('RouteContract', route);
     }

package/src/Valkyrja/Http/Server/Handler/RequestHandler.ts

@@ -17,7 +17,7 @@ import { Stream } from '../../Message/Stream/Stream.ts';
 import { HttpResponseException } from '../../Message/Throwable/Exception/HttpResponseException.ts';
 import { RequestReceivedHandler } from '../../Middleware/Handler/RequestReceivedHandler.ts';
 import { SendingResponseHandler } from '../../Middleware/Handler/SendingResponseHandler.ts';
-import { TerminatedHandler } from '../../Middleware/Handler/TerminatedHandler.ts';
+import { ResponseSentHandler } from '../../Middleware/Handler/ResponseSentHandler.ts';
 import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.ts';
 import { Router } from '../../Routing/Dispatcher/Router.ts';
 
@@ -26,7 +26,7 @@ import type { ServerRequestContract } from '../../Message/Request/Contract/Serve
 import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.ts';
 import type { RequestReceivedHandlerContract } from '../../Middleware/Handler/Contract/RequestReceivedHandlerContract.ts';
 import type { SendingResponseHandlerContract } from '../../Middleware/Handler/Contract/SendingResponseHandlerContract.ts';
-import type { TerminatedHandlerContract } from '../../Middleware/Handler/Contract/TerminatedHandlerContract.ts';
+import type { ResponseSentHandlerContract } from '../../Middleware/Handler/Contract/ResponseSentHandlerContract.ts';
 import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.ts';
 import type { RouterContract } from '../../Routing/Dispatcher/Contract/RouterContract.ts';
 import type { RequestHandlerContract } from './Contract/RequestHandlerContract.ts';
@@ -38,7 +38,7 @@ export class RequestHandler implements RequestHandlerContract {
         protected requestReceivedHandler: RequestReceivedHandlerContract = new RequestReceivedHandler(),
         protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
         protected sendingResponseHandler: SendingResponseHandlerContract = new SendingResponseHandler(),
-        protected terminatedHandler: TerminatedHandlerContract = new TerminatedHandler(),
+        protected responseSentHandler: ResponseSentHandlerContract = new ResponseSentHandler(),
         protected debug: boolean = false,
     ) {}
 
@@ -79,7 +79,7 @@ export class RequestHandler implements RequestHandlerContract {
     }
 
     terminate(request: ServerRequestContract, response: ResponseContract): void {
-        this.terminatedHandler.terminated(request, response);
+        this.responseSentHandler.responseSent(request, response);
     }
 
     run(request: ServerRequestContract, nodeResponse: ServerResponse): void {

package/src/Valkyrja/Validation/Validator/Validator.ts

@@ -39,10 +39,7 @@ export class Validator implements ValidatorContract {
     }
 
     getFirstErrorMessage(): string {
-        const keys = Object.keys(this.errorMessages);
-        const firstKey = keys[0];
-
-        return firstKey !== undefined ? (this.errorMessages[firstKey] ?? '') : '';
+        return Object.values(this.errorMessages)[0] ?? '';
     }
 
     protected validateRule(rule: RuleContract, subject: string): void {

package/src/Valkyrja/Cli/Middleware/Contract/ExitedMiddlewareContract.ts

@@ -1,22 +0,0 @@
-/*
- * This file is part of the Valkyrja package.
- *
- * (c) Melech Mizrachi <melechmizrachi@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { InputContract } from '../../Interaction/Input/Contract/InputContract.ts';
-import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.ts';
-import type { ExitedHandlerContract } from '../Handler/Contract/ExitedHandlerContract.ts';
-
-export interface ExitedMiddlewareContract {
-    exited(input: InputContract, output: OutputContract, handler: ExitedHandlerContract): void;
-}
-
-export namespace ExitedMiddlewareContract {
-    export function instanceOf(value: unknown): value is ExitedMiddlewareContract {
-        return typeof value === 'object' && value !== null && 'exited' in value;
-    }
-}