@valkyrjaio/valkyrja 26.1.0 → 26.3.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.3.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.3.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'July 25 2026 20:40:59 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/Application/Kernel/Valkyrja.ts

@@ -47,18 +47,21 @@ export class Valkyrja implements ApplicationContract {
             return this.providers;
         }
 
-        const providers: ComponentProviderContract[][] = [];
-
         for (const provider of this.config.providers) {
-            providers.push(provider.getComponentProviders(this));
-            providers.push([provider]);
+            this.collectProviders(provider);
         }
 
-        this.providers = [...new Set(providers.flat())];
-
         return this.providers;
     }
 
+    protected collectProviders(provider: ComponentProviderContract): void {
+        for (const subProvider of provider.getComponentProviders(this)) {
+            this.collectProviders(subProvider);
+        }
+
+        this.providers.push(provider);
+    }
+
     getContainerProviders(): ServiceProviderContract[] {
         if (this.serviceProviders.length > 0) {
             return this.serviceProviders;

package/src/Valkyrja/Application/Provider/HttpApplicationComponentProvider.ts

@@ -8,6 +8,11 @@
  */
 
 import { ContainerComponentProvider } from '../../Container/Provider/ContainerComponentProvider.ts';
+import { HttpMessageComponentProvider } from '../../Http/Message/Provider/HttpMessageComponentProvider.ts';
+import { HttpMiddlewareComponentProvider } from '../../Http/Middleware/Provider/HttpMiddlewareComponentProvider.ts';
+import { HttpRoutingCliComponentProvider } from '../../Http/Routing/Provider/HttpRoutingCliComponentProvider.ts';
+import { HttpRoutingComponentProvider } from '../../Http/Routing/Provider/HttpRoutingComponentProvider.ts';
+import { HttpServerComponentProvider } from '../../Http/Server/Provider/HttpServerComponentProvider.ts';
 import { ApplicationComponentProvider } from './ApplicationComponentProvider.ts';
 
 import type { ApplicationContract } from '../Kernel/Contract/ApplicationContract.ts';
@@ -15,6 +20,13 @@ import type { ComponentProviderContract } from './Contract/ComponentProviderCont
 
 export class HttpApplicationComponentProvider extends ApplicationComponentProvider {
     override getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
-        return [new ContainerComponentProvider()];
+        return [
+            new ContainerComponentProvider(),
+            new HttpMessageComponentProvider(),
+            new HttpMiddlewareComponentProvider(),
+            new HttpRoutingComponentProvider(),
+            new HttpRoutingCliComponentProvider(),
+            new HttpServerComponentProvider(),
+        ];
     }
 }

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());
     }