@flancer32/teq-web 0.4.0 → 0.6.0

package/src/Back/PipelineEngine.mjs

@@ -0,0 +1,216 @@
+// @ts-check
+
+/**
+ * Pipeline Engine is the single request-lifecycle coordination component.
+ * It executes handlers in three deterministic stages:
+ * `INIT -> PROCESS -> FINALIZE`.
+ */
+export const __deps__ = Object.freeze({
+    dtoRequestContextFactory: 'Fl32_Web_Back_Dto_RequestContext__Factory$',
+    logger: 'Fl32_Web_Back_Logger$',
+    respond: 'Fl32_Web_Back_Helper_Respond$',
+    helpOrder: 'Fl32_Web_Back_Helper_Order_Kahn$',
+    STAGE: 'Fl32_Web_Back_Enum_Stage$',
+});
+
+const KEY_STAGE = Symbol('stage');
+
+export default class Fl32_Web_Back_PipelineEngine {
+    /* eslint-disable jsdoc/require-param-description,jsdoc/check-param-names */
+    /**
+     * @param {object} params
+     * @param {Fl32_Web_Back_Dto_RequestContext$Factory} params.dtoRequestContextFactory
+     * @param {Fl32_Web_Back_Logger} params.logger
+     * @param {Fl32_Web_Back_Helper_Respond} params.respond
+     * @param {Fl32_Web_Back_Helper_Order_Kahn} params.helpOrder
+     * @param {Fl32_Web_Back_Enum_Stage} params.STAGE
+     */
+    constructor(
+        {
+            dtoRequestContextFactory,
+            logger,
+            respond,
+            helpOrder,
+            STAGE,
+        }
+    ) {
+        /* eslint-enable jsdoc/require-param-description,jsdoc/check-param-names */
+        /** @type {Map<string, Fl32_Web_Back_Api_Handler>} */
+        const handlers = new Map();
+        /** @type {Fl32_Web_Back_Api_Handler[]} */
+        let initHandlers = [];
+        /** @type {Fl32_Web_Back_Api_Handler[]} */
+        let processHandlers = [];
+        /** @type {Fl32_Web_Back_Api_Handler[]} */
+        let finalizeHandlers = [];
+        let isLocked = false;
+
+        /**
+         * @param {Fl32_Web_Node_Http_IncomingMessage|Fl32_Web_Node_Http2_ServerRequest} request
+         * @param {Fl32_Web_Back_Response_Target} response
+         * @returns {Fl32_Web_Back_Dto_RequestContext}
+         */
+        function createRequestContext(request, response) {
+            let completed = false;
+            /** @type {Fl32_Web_Back_Dto_RequestContext & {[KEY_STAGE]: string|null}} */
+            const context = dtoRequestContextFactory.create();
+            context.request = request;
+            context.response = response;
+            context.data = {};
+            context.completed = false;
+            context.complete = () => {
+                context.completed = true;
+            };
+            context.isCompleted = () => completed;
+            context[KEY_STAGE] = null;
+
+            Object.defineProperty(context, 'completed', {
+                configurable: false,
+                enumerable: true,
+                get() {
+                    return completed;
+                },
+                set(value) {
+                    if (value !== true && value !== false) {
+                        throw new Error('Request completion flag accepts only boolean values');
+                    }
+                    if (value === false && completed) {
+                        throw new Error('Request completion flag cannot be reset');
+                    }
+                    if (value === true && !completed) {
+                        if (context[KEY_STAGE] !== STAGE.PROCESS) {
+                            throw new Error('Only PROCESS handlers may complete request processing');
+                        }
+                        completed = true;
+                    }
+                },
+            });
+
+            return context;
+        }
+
+        /**
+         * @param {Fl32_Web_Back_Api_Handler} handler
+         * @param {string} stage
+         * @param {Fl32_Web_Back_Dto_RequestContext & {[KEY_STAGE]: string|null}} context
+         * @returns {Promise<void>}
+         */
+        async function runHandler(handler, stage, context) {
+            context[KEY_STAGE] = stage;
+            await handler.handle(context);
+        }
+
+        /**
+         * @returns {void}
+         */
+        this.orderHandlers = function () {
+            const init = [];
+            const process = [];
+            const finalize = [];
+
+            for (const handler of handlers.values()) {
+                const info = handler.getRegistrationInfo();
+                if (info.stage === STAGE.INIT) {
+                    init.push(handler);
+                } else if (info.stage === STAGE.PROCESS) {
+                    process.push(handler);
+                } else if (info.stage === STAGE.FINALIZE) {
+                    finalize.push(handler);
+                } else {
+                    throw new Error(`Unsupported handler stage '${String(info.stage)}'`);
+                }
+            }
+
+            initHandlers = helpOrder.sort(init);
+            processHandlers = helpOrder.sort(process);
+            finalizeHandlers = helpOrder.sort(finalize);
+            isLocked = true;
+        };
+
+        /**
+         * @returns {void}
+         */
+        this.lockHandlers = () => this.orderHandlers();
+
+        /**
+         * @param {Fl32_Web_Back_Api_Handler} handler
+         * @returns {void}
+         */
+        this.addHandler = function (handler) {
+            if (isLocked) {
+                throw new Error('Handler registration is locked after pipeline ordering');
+            }
+            const info = handler.getRegistrationInfo();
+            if (!info?.name) {
+                throw new Error('Handler registration requires a non-empty name');
+            }
+            handlers.set(info.name, handler);
+        };
+
+        /**
+         * @param {Fl32_Web_Back_Api_Handler} handler
+         * @returns {void}
+         */
+        this.registerHandler = (handler) => this.addHandler(handler);
+
+        /**
+         * @param {Fl32_Web_Node_Http_IncomingMessage|Fl32_Web_Node_Http2_ServerRequest} req
+         * @param {Fl32_Web_Back_Response_Target} res
+         * @returns {Promise<void>}
+         */
+        this.onEventRequest = async function (req, res) {
+            if (!isLocked) {
+                this.orderHandlers();
+            }
+            /** @type {Fl32_Web_Back_Dto_RequestContext & {[KEY_STAGE]: string|null}} */
+            const context = createRequestContext(req, res);
+
+            try {
+                for (const handler of initHandlers) {
+                    try {
+                        await runHandler(handler, STAGE.INIT, context);
+                    } catch (error) {
+                        logger.exception(error);
+                    }
+                }
+
+                for (const handler of processHandlers) {
+                    if (context.isCompleted()) {
+                        break;
+                    }
+                    try {
+                        await runHandler(handler, STAGE.PROCESS, context);
+                    } catch (error) {
+                        logger.exception(error);
+                        if (respond.isWritable(res)) {
+                            respond.code500_InternalServerError({res, body: 'Internal Server Error'});
+                        }
+                        context.completed = true;
+                        break;
+                    }
+                }
+
+                if (!context.isCompleted() && respond.isWritable(res)) {
+                    logger.error(`404 Not Found: ${req.url}`);
+                    respond.code404_NotFound({res});
+                }
+            } finally {
+                for (const handler of finalizeHandlers) {
+                    try {
+                        await runHandler(handler, STAGE.FINALIZE, context);
+                    } catch (error) {
+                        logger.exception(error);
+                    }
+                }
+                context[KEY_STAGE] = null;
+            }
+        };
+
+        /**
+         * @param {Fl32_Web_Node_Http_IncomingMessage|Fl32_Web_Node_Http2_ServerRequest} req
+         * @param {Fl32_Web_Back_Response_Target} res
+         * @returns {Promise<void>}
+         */
+        this.handleRequest = async (req, res) => this.onEventRequest(req, res);
+    }
+}

package/src/Back/{Server.js → Server.mjs}

@@ -1,55 +1,63 @@
+// @ts-check
+
 /**
  * Web server implementation supporting HTTP/1 and HTTP/2 protocols.
- * Handles incoming requests and delegates them to the dispatcher.
- *
- * @property {function(): module:http.Server} getInstance - Returns the server instance.
- * @property {function(Fl32_Web_Back_Server_Config.Dto): Promise<void>} start - Starts the server with given configuration.
- * @property {function(): Promise<void>} stop - Stops the server.
+ * Handles incoming requests and delegates them to the Pipeline Engine.
  */
+export const __deps__ = Object.freeze({
+    http: 'node_http',
+    http2: 'node_http2',
+    config: 'Fl32_Web_Back_Config_Runtime$',
+    logger: 'Fl32_Web_Back_Logger$',
+    pipelineEngine: 'Fl32_Web_Back_PipelineEngine$',
+    SERVER_TYPE: 'Fl32_Web_Back_Enum_Server_Type$',
+});
+
 export default class Fl32_Web_Back_Server {
     /* eslint-disable jsdoc/require-param-description,jsdoc/check-param-names */
     /**
-     * @param {typeof import('node:http')} http
-     * @param {typeof import('node:http2')} http2
-     * @param {Fl32_Web_Back_Defaults} DEF
-     * @param {Fl32_Web_Back_Logger} logger
-     * @param {Fl32_Web_Back_Dispatcher} dispatcher
-     * @param {typeof Fl32_Web_Back_Enum_Server_Type} SERVER_TYPE
+     * @param {object} deps
+     * @param {Fl32_Web_Node_Http} deps.http
+     * @param {Fl32_Web_Node_Http2} deps.http2
+     * @param {Fl32_Web_Back_Config_Runtime} deps.config
+     * @param {Fl32_Web_Back_Logger} deps.logger
+     * @param {Fl32_Web_Back_PipelineEngine} deps.pipelineEngine
+     * @param {Fl32_Web_Back_Enum_Server_Type} deps.SERVER_TYPE
      */
     constructor(
         {
-            'node:http': http,
-            'node:http2': http2,
-            Fl32_Web_Back_Defaults$: DEF,
-            Fl32_Web_Back_Logger$: logger,
-            Fl32_Web_Back_Dispatcher$: dispatcher,
-            Fl32_Web_Back_Enum_Server_Type$: SERVER_TYPE,
+            http,
+            http2,
+            config,
+            logger,
+            pipelineEngine,
+            SERVER_TYPE,
         }
     ) {
         /* eslint-enable jsdoc/require-param-description,jsdoc/check-param-names */
         // VARS
-        const {createServer} = http;
-        const {createServer: createServerH2, createSecureServer} = http2;
-        /** @type {module:http.Server} */
+        const { createServer } = http;
+        const { createServer: createServerH2, createSecureServer } = http2;
+        /** @type {Fl32_Web_Node_Http_Server} */
         let _instance;
 
         // MAIN
         /**
-         * @returns {module:http.Server}
+         * @returns {Fl32_Web_Node_Http_Server}
          */
         this.getInstance = () => _instance;
 
         /**
          * Starts the server with optional configuration.
-         * @param {Fl32_Web_Back_Server_Config.Dto} [cfg] - Server configuration
+         * @param {Fl32_Web_Back_Config_Runtime_Server} [cfg]
          * @returns {Promise<void>}
          */
         this.start = async function (cfg) {
-            // order handlers in the dispatcher
-            dispatcher.orderHandlers();
+            pipelineEngine.lockHandlers();
             // create server
-            const port = cfg?.port ?? DEF.PORT;
-            const type = cfg?.type ?? SERVER_TYPE.HTTP;
+            const port = cfg?.port ?? config.server.port;
+            const type = cfg?.type ?? config.server.type;
+            const tls = cfg?.tls ?? config.server.tls;
 
             if (type === SERVER_TYPE.HTTP2) {
                 _instance = createServerH2();
@@ -58,18 +66,18 @@ export default class Fl32_Web_Back_Server {
                 _instance = createServer({});
                 logger.info(`Starting server in HTTP/1 mode on port ${port}...`);
             } else if (type === SERVER_TYPE.HTTPS) {
-                if (!cfg.tls?.key || !cfg.tls?.cert) {
+                if (!tls?.key || !tls?.cert) {
                     logger.error('HTTPS server requires TLS key and certificate');
                     throw new Error('TLS key and certificate are required for HTTPS server');
                 }
-                _instance = createSecureServer(cfg.tls);
+                _instance = createSecureServer(tls);
                 logger.info(`Starting server in HTTPS (HTTP/2 + TLS) mode on port ${port}...`);
             } else {
                 logger.error(`Unsupported server type: ${type}`);
                 throw new Error(`Server type '${type}' is not supported`);
             }
 
-            _instance.on('request', dispatcher.onEventRequest);
+            _instance.on('request', pipelineEngine.handleRequest);
             _instance.listen(port);
         };
 
@@ -89,4 +97,4 @@ export default class Fl32_Web_Back_Server {
             }
         };
     }
-}
+}

package/types.d.ts

@@ -1,25 +1,48 @@
 declare global {
-  type Fl32_Web_Back_Api_Handler = import("./src/Back/Api/Handler.js").default;
-  type Fl32_Web_Back_Defaults = import("./src/Back/Defaults.js").default;
-  type Fl32_Web_Back_Dispatcher = import("./src/Back/Dispatcher.js").default;
-  type Fl32_Web_Back_Dto_Handler_Info = import("./src/Back/Dto/Handler/Info.js").default;
-  type Fl32_Web_Back_Dto_Handler_Source = import("./src/Back/Dto/Handler/Source.js").default;
-  type Fl32_Web_Back_Enum_Server_Type = import("./src/Back/Enum/Server/Type.js").default;
-  type Fl32_Web_Back_Enum_Stage = import("./src/Back/Enum/Stage.js").default;
-  type Fl32_Web_Back_Handler_Pre_Log = import("./src/Back/Handler/Pre/Log.js").default;
-  type Fl32_Web_Back_Handler_Static = import("./src/Back/Handler/Static.js").default;
-  type Fl32_Web_Back_Handler_Static_A_Config = import("./src/Back/Handler/Static/A/Config.js").default;
-  type Fl32_Web_Back_Handler_Static_A_Fallback = import("./src/Back/Handler/Static/A/Fallback.js").default;
-  type Fl32_Web_Back_Handler_Static_A_FileService = import("./src/Back/Handler/Static/A/FileService.js").default;
-  type Fl32_Web_Back_Handler_Static_A_Registry = import("./src/Back/Handler/Static/A/Registry.js").default;
-  type Fl32_Web_Back_Handler_Static_A_Resolver = import("./src/Back/Handler/Static/A/Resolver.js").default;
-  type Fl32_Web_Back_Helper_Cast = import("./src/Back/Helper/Cast.js").default;
-  type Fl32_Web_Back_Helper_Mime = import("./src/Back/Helper/Mime.js").default;
-  type Fl32_Web_Back_Helper_Order_Kahn = import("./src/Back/Helper/Order/Kahn.js").default;
-  type Fl32_Web_Back_Helper_Respond = import("./src/Back/Helper/Respond.js").default;
-  type Fl32_Web_Back_Logger = import("./src/Back/Logger.js").default;
-  type Fl32_Web_Back_Server = import("./src/Back/Server.js").default;
-  type Fl32_Web_Back_Server_Config = import("./src/Back/Server/Config.js").default;
-  type Fl32_Web_Back_Server_Config_Tls = import("./src/Back/Server/Config/Tls.js").default;
+  type Fl32_Web_Back_Api_Handler = import("./src/Back/Api/Handler.mjs").default;
+  type Fl32_Web_Back_Config_Runtime = import("./src/Back/Config/Runtime.mjs").Data;
+  type Fl32_Web_Back_Config_Runtime$Factory = import("./src/Back/Config/Runtime.mjs").Factory;
+  type Fl32_Web_Back_Config_Runtime_Server = import("./src/Back/Config/Runtime.mjs").Server;
+  type Fl32_Web_Back_Config_Runtime_Tls = import("./src/Back/Config/Runtime/Tls.mjs").Data;
+  type Fl32_Web_Back_Config_Runtime_Tls$Factory = import("./src/Back/Config/Runtime/Tls.mjs").Factory;
+  type Fl32_Web_Back_Config_Runtime_Params = {server?: {port?: unknown, type?: unknown, tls?: unknown}};
+  type Fl32_Web_Back_Config_Runtime_Tls_Params = {ca?: unknown, cert?: unknown, key?: unknown};
+  type Fl32_Web_Back_Dto_Info = import("./src/Back/Dto/Info.mjs").default;
+  type Fl32_Web_Back_Dto_Info$Factory = import("./src/Back/Dto/Info.mjs").Factory;
+  type Fl32_Web_Back_Dto_RequestContext = import("./src/Back/Dto/RequestContext.mjs").default;
+  type Fl32_Web_Back_Dto_RequestContext$Factory = import("./src/Back/Dto/RequestContext.mjs").Factory;
+  type Fl32_Web_Back_Dto_Source = import("./src/Back/Dto/Source.mjs").default;
+  type Fl32_Web_Back_Dto_Source$Factory = import("./src/Back/Dto/Source.mjs").Factory;
+  type Fl32_Web_Back_Enum_Server_Type = import("./src/Back/Enum/Server/Type.mjs").default;
+  type Fl32_Web_Back_Enum_Stage = import("./src/Back/Enum/Stage.mjs").default;
+  type Fl32_Web_Back_Handler_Pre_Log = import("./src/Back/Handler/Pre/Log.mjs").default;
+  type Fl32_Web_Back_Handler_Static = import("./src/Back/Handler/Static.mjs").default;
+  type Fl32_Web_Back_Handler_Static_A_Config = import("./src/Back/Handler/Static/A/Config.mjs").default;
+  type Fl32_Web_Back_Handler_Static_A_Config_Value = {root: string, prefix: string, allow?: Record<string, string[]>, defaults: string[]};
+  type Fl32_Web_Back_Handler_Static_A_Fallback = import("./src/Back/Handler/Static/A/Fallback.mjs").default;
+  type Fl32_Web_Back_Handler_Static_A_FileService = import("./src/Back/Handler/Static/A/FileService.mjs").default;
+  type Fl32_Web_Back_Handler_Static_A_Match = {config: Fl32_Web_Back_Handler_Static_A_Config_Value, rel: string};
+  type Fl32_Web_Back_Handler_Static_A_Registry = import("./src/Back/Handler/Static/A/Registry.mjs").default;
+  type Fl32_Web_Back_Handler_Static_A_Resolver = import("./src/Back/Handler/Static/A/Resolver.mjs").default;
+  type Fl32_Web_Back_Helper_Cast = import("./src/Back/Helper/Cast.mjs").default;
+  type Fl32_Web_Back_Helper_Mime = import("./src/Back/Helper/Mime.mjs").default;
+  type Fl32_Web_Back_Helper_Order_Kahn = import("./src/Back/Helper/Order/Kahn.mjs").default;
+  type Fl32_Web_Back_Helper_Respond = import("./src/Back/Helper/Respond.mjs").default;
+  type Fl32_Web_Back_Logger = import("./src/Back/Logger.mjs").default;
+  type Fl32_Web_Back_PipelineEngine = import("./src/Back/PipelineEngine.mjs").default;
+  type Fl32_Web_Back_Response_Body = string | object;
+  type Fl32_Web_Back_Response_Headers = {[key: string]: string};
+  type Fl32_Web_Back_Response_Target = Fl32_Web_Node_Http_ServerResponse | Fl32_Web_Node_Http2_ServerResponse;
+  type Fl32_Web_Back_Server = import("./src/Back/Server.mjs").default;
+  type Fl32_Web_Node_Fs = typeof import("node:fs");
+  type Fl32_Web_Node_Http = typeof import("node:http");
+  type Fl32_Web_Node_Http_Server = import("node:http").Server;
+  type Fl32_Web_Node_Http_IncomingMessage = import("node:http").IncomingMessage;
+  type Fl32_Web_Node_Http_ServerResponse = import("node:http").ServerResponse;
+  type Fl32_Web_Node_Http2 = typeof import("node:http2");
+  type Fl32_Web_Node_Http2_ServerRequest = import("node:http2").Http2ServerRequest;
+  type Fl32_Web_Node_Http2_ServerResponse = import("node:http2").Http2ServerResponse;
+  type Fl32_Web_Node_Path = typeof import("node:path");
 }
+
 export {};

package/src/AGENTS.md

@@ -1,108 +0,0 @@
-# AI Agents Configuration for Source Directory
-
-This document defines **long-term, project-agnostic** conventions that AI agents must follow when reading, creating, refactoring, or testing code under any `src/` directory. These guidelines are **permanent** and apply to **all** tasks in this area.
-
----
-
-## 1. Directory & File Organization
-
-* **AZ-structuring**
-
-    * **A-struct**: decompose a single “root” module into its private implementation parts under an `A/` subfolder.
-
-      ```text
-      src/Feature/Component.js
-      src/Feature/Component/A/Part1.js
-      src/Feature/Component/A/Part2.js
-      ```
-
-      Files under `A/` are private to their parent.
-    * **Z-struct**: helper modules whose changes do not affect siblings live under a `Z/` subfolder.
-
-* **Visibility boundaries**: anything **outside** `A/` or `Z/` is public API.
-
-* **Role → Feature layering**
-
-    * First level: by architectural layer (e.g. `Back/`, `Front/`, `Shared/`).
-    * Second level: by business feature or component.
-
-* **Mirror in tests**
-
-    * For every `src/.../X.js` there must be a matching `test/unit/.../X.test.mjs` with the same relative path and filename.
-
----
-
-## 2. Class Naming (FQN)
-
-* Map file path to fully qualified class name (FQN). Example:
-
-  ```text
-  src/Back/Handler/Static/A/Config.js => class Back_Handler_Static_A_Config
-  ```
-
----
-
-## 3. Dependency Injection, `this` & Closures
-
-* **DI Container**
-
-    * Inject all external services (file system, path, network, helpers, loggers, factories, enums) via a DI container.
-* **Private state via closure**
-
-    * Do **not** assign injected dependencies to `this`.
-    * Capture each in a `const` inside the constructor and expose only public methods.
-
-```js
-class Example {
-    constructor({helperService, logger}) {
-        this.handle = (req, res) => {
-            if (!helperService.isWritable(res)) return false;
-            logger.info('Processing');
-            return true;
-        };
-    }
-}
-```
-
----
-
-## 4. Comments & Annotations
-
-* **Language**: all comments and JSDoc must be in **English**.
-* **JSDoc**: use `@param {Type}` and `@returns {Type}` on every public method.
-* **Class annotation**: annotate all classes with a JSDoc `@class` tag and description.
-
----
-
-## 5. Error Handling
-
-* **Module-level**
-
-    * Do **not** catch all exceptions in each module.
-    * Catch only **expected, domain-specific** errors when a meaningful fallback exists.
-* **Top-level handler**
-
-    * Wrap the entire pipeline in a single `try/catch` at the entry point.
-    * In that catch, use `logger.exception(error)` and return a safe default (`false`, `null`, or `[]`).
-
----
-
-## 6. Testing Conventions
-
-Refer to the [AI Agent Unit Testing Instructions](../test/unit/AGENTS.md) for project-specific testing guidelines.
-
----
-
-## 7. Ongoing Responsibilities
-
-AI agents must always:
-
-1. **Enforce AZ-structuring** when adding or refactoring code.
-2. **Preserve FQN mapping** between file paths and class names.
-3. **Use DI + closures**—never attach injected services to `this`.
-4. **Write English JSDoc** for every new or modified public API, including `@class` on all classes.
-5. **Catch and log errors** at the top level; handle known cases locally.
-6. **Generate or update unit tests** with full coverage for every behavior change (see unit testing guidelines).
-7. **Maintain test-source mirror** so no source file exists without a corresponding test.
-
-These policies are **permanent** and must be validated on every code change.

package/src/Back/Api/Handler.js

@@ -1,26 +0,0 @@
-/**
- * Interface for web request handlers used by the dispatcher in this plugin.
- * Defines the structure and behavior of a handler.
- *
- * @interface
- */
-export default class Fl32_Web_Back_Api_Handler {
-    /* eslint-disable no-unused-vars */
-    /**
-     * Handles the incoming web request.
-     * @param {module:http.IncomingMessage|module:http2.Http2ServerRequest} req - The incoming HTTP request object.
-     * @param {module:http.ServerResponse|module:http2.Http2ServerResponse} res - The HTTP response object.
-     * @returns {Promise<boolean>} - Returns true if the request was handled, false otherwise.
-     */
-    async handle(req, res) {
-        throw new Error('Method not implemented');
-    }
-
-    /**
-     * Provides metadata for dispatcher registration.
-     * @returns {Fl32_Web_Back_Dto_Handler_Info.Dto}
-     */
-    getRegistrationInfo() {
-        throw new Error('Method not implemented');
-    }
-}

package/src/Back/Defaults.js

@@ -1,6 +0,0 @@
-/**
- * Plugin constants (hardcoded configuration) for backend code.
- */
-export default class Fl32_Web_Back_Defaults {
-    PORT = 3000;
-}

package/src/Back/Dispatcher.js

@@ -1,115 +0,0 @@
-/**
- * Dispatcher for HTTP(S) requests with three-stage handler execution: pre, process, post.
- *
- * Handlers are registered via `addHandler()` and activated by `orderHandlers()`.
- * On each request, pre-handlers run first, then process-handlers (until one returns true),
- * and finally post-handlers are always executed.
- *
- * If no process handler responds, a 404 is sent. If one throws, a 500 is returned.
- */
-export default class Fl32_Web_Back_Dispatcher {
-    /* eslint-disable jsdoc/require-param-description,jsdoc/check-param-names */
-    /**
-     * @param {Fl32_Web_Back_Logger} logger
-     * @param {Fl32_Web_Back_Helper_Respond} respond
-     * @param {Fl32_Web_Back_Helper_Order_Kahn} helpOrder
-     * @param {typeof Fl32_Web_Back_Enum_Stage} STAGE
-     */
-    constructor(
-        {
-            Fl32_Web_Back_Logger$: logger,
-            Fl32_Web_Back_Helper_Respond$: respond,
-            Fl32_Web_Back_Helper_Order_Kahn$: helpOrder,
-            Fl32_Web_Back_Enum_Stage$: STAGE,
-        }
-    ) {
-        /* eslint-enable jsdoc/check-param-names */
-        // VARS
-        /** @type {Map<string, Fl32_Web_Back_Api_Handler>} */
-        const _handlers = new Map();
-
-        /** @type {Fl32_Web_Back_Api_Handler[]} */
-        let _pre = [], _process = [], _post = [];
-
-        // MAIN
-
-        /**
-         * Registers a handler. Requires a unique name and stage.
-         *
-         * @param {Fl32_Web_Back_Api_Handler} handler
-         */
-        this.addHandler = function (handler) {
-            const info = handler.getRegistrationInfo();
-            _handlers.set(info.name, handler);
-        };
-
-        /**
-         * Executes registered handlers for one HTTP request.
-         *
-         * @param {module:http.IncomingMessage|module:http2.Http2ServerRequest} req
-         * @param {module:http.ServerResponse|module:http2.Http2ServerResponse} res
-         * @returns {Promise<void>}
-         */
-        this.onEventRequest = async function (req, res) {
-            try {
-                // Execute all pre-handlers (errors are isolated)
-                for (const h of _pre) {
-                    try {
-                        await h.handle(req, res);
-                    } catch (e) {
-                        logger.exception(e);
-                    }
-                }
-
-                // Execute process-handlers (stop at first successful)
-                let handled = false;
-                for (const h of _process) {
-                    try {
-                        handled = await h.handle(req, res);
-                        if (handled) break;
-                    } catch (e) {
-                        logger.exception(e);
-                        respond.code500_InternalServerError({res, body: e?.message});
-                        break;
-                    }
-                }
-
-                // If not handled at all and no error occurred
-                if (respond.isWritable(res)) {
-                    logger.error(`404 Not Found: ${req.url}`);
-                    respond.code404_NotFound({res});
-                }
-            } finally {
-                // Always run all post-handlers (errors are isolated)
-                for (const h of _post) {
-                    try {
-                        await h.handle(req, res);
-                    } catch (e) {
-                        logger.exception(e);
-                    }
-                }
-            }
-        };
-
-        /**
-         * Sorts registered handlers by stage.
-         */
-        this.orderHandlers = function () {
-            const pre = [], process = [], post = [];
-
-            for (const handler of _handlers.values()) {
-                const dto = handler.getRegistrationInfo();
-                if (dto.stage === STAGE.PRE) {
-                    pre.push(handler);
-                } else if (dto.stage === STAGE.PROCESS) {
-                    process.push(handler);
-                } else if (dto.stage === STAGE.POST) post.push(handler);
-            }
-
-            _pre = helpOrder.sort(pre);
-            _process = helpOrder.sort(process);
-            _post = helpOrder.sort(post);
-        };
-    }
-
-}