corecdtl 0.1.7 → 0.1.9

package/dist/http/content/parser.js

@@ -60,5 +60,5 @@ exports.contentParserTable = {
     "application/json": JSON.parse,
     "application/x-www-form-urlencoded": formParse,
     "multipart/form-data": multipartParser,
-    "text/plain": (b) => decoder.decode
+    "text/plain": (b) => decoder.decode(b)
 };

package/dist/http/context/ApiContext.js

@@ -42,7 +42,7 @@ class ApiContext extends HttpContext_1.default {
                         return;
                     // --- NOT FOUND ---
                     case http_1.Http.RetFlagBits.FLAG_NOT_FOUND:
-                        if (this.enableCors) {
+                        if (this.isEnableCors) {
                             socket.write(this.errorRespMap.RESP_204);
                         }
                         else {

package/dist/http/context/HttpContext.d.ts

@@ -2,7 +2,7 @@ import { Http } from "../../http";
 import { type IHttpCore, type ICPool } from "../../hypernode";
 import net from "net";
 import { createAccumulators } from "../factory/accumulator";
-declare abstract class HttpContext {
+declare abstract class HttpContext implements Http.HttpContext {
     protected MODE: "web" | "api";
     protected abstract contentDecoding: Http.ContentDecoding;
     protected abstract contentEncoding: Http.ContentEncoding;
@@ -15,7 +15,7 @@ declare abstract class HttpContext {
     protected accumulators: ReturnType<typeof createAccumulators>;
     protected abstract parseInitial: Http.ParseInitialFn;
     protected state: Http.ServerState;
-    protected enableCors: boolean;
+    protected isEnableCors: boolean;
     protected httpCore: IHttpCore;
     protected setHttpCore(mode: "web" | "api"): void;
     private bootstrapPoolChunkProgressionFn?;
@@ -25,7 +25,7 @@ declare abstract class HttpContext {
     protected initRuntime(): void;
     protected registerRouters(mainRoute: Http.Route): void;
     private buildRoute;
-    enabledCors(cfg: Http.CorsConfig): void;
+    enableCors(cfg: Http.CorsConfig): this;
     setTimeout(timeout: number): void;
     setRequestQuerySize(requestQuerySize: number): void;
     setMaxHeaderNameSize(maxHeaderNameSize: number): void;

package/dist/http/context/HttpContext.js

@@ -24,7 +24,7 @@ class HttpContext {
             RESP_414: Buffer.from("HTTP/1.1 414 Request-URI Too Large\r\nContent-Length: 0\r\n\r\n"),
             RESP_204: Buffer.from("HTTP/1.1 204 No Content\r\n\r\n")
         };
-        this.enableCors = false;
+        this.isEnableCors = false;
         this.state = {
             corsHeaders: "",
             maxHeaderSize: opts?.maxHeaderSize || 10 * 1024,
@@ -157,7 +157,7 @@ class HttpContext {
             throw new Error("Building Route Tree");
         this.routePipes = routePipes;
     }
-    enabledCors(cfg) {
+    enableCors(cfg) {
         function toHeaderValue(v) {
             if (!v)
                 return undefined;
@@ -186,7 +186,8 @@ class HttpContext {
         this.errorRespMap.RESP_204 = Buffer.from("HTTP/1.1 404 Not Found\r\n" +
             this.state.corsHeaders + "\r\n" +
             "Content-Length: 0\r\n\r\n");
-        this.enableCors = true;
+        this.isEnableCors = true;
+        return this;
     }
     setTimeout(timeout) {
         timeout > 0 ? this.state.timeout = timeout : null;

package/dist/http/context/WebContext.js

@@ -97,7 +97,7 @@ class WebContext extends HttpContext_1.default {
                         return;
                     // --- NOT FOUND ---
                     case http_1.Http.RetFlagBits.FLAG_NOT_FOUND:
-                        if (this.enableCors) {
+                        if (this.isEnableCors) {
                             socket.write(this.errorRespMap.RESP_204);
                         }
                         else {
@@ -197,7 +197,7 @@ class WebContext extends HttpContext_1.default {
             _data = fs_1.default.readFileSync(this.spaRootPath);
         }
         catch (error) {
-            console.error(error);
+            console.error("SPA file not found:", this.spaRootPath, error);
             return;
         }
         const __resp = Buffer.from("HTTP/1.1 200 OK\r\n" +
@@ -279,27 +279,34 @@ class WebContext extends HttpContext_1.default {
     }
     setAllAssets() {
         const walk = (dir, baseUrl) => {
-            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path_1.default.join(dir, entry.name);
-                const urlPath = path_1.default.posix.join(baseUrl, entry.name);
-                if (entry.isDirectory()) {
-                    walk(fullPath, urlPath);
-                    continue;
+            try {
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path_1.default.join(dir, entry.name);
+                    const urlPath = path_1.default.posix.join(baseUrl, entry.name);
+                    if (entry.isDirectory()) {
+                        walk(fullPath, urlPath);
+                        continue;
+                    }
+                    if (!entry.isFile())
+                        continue;
+                    const asset = this.loadAsset(urlPath);
+                    if (!asset)
+                        continue;
+                    this.assetCache.set(urlPath, asset);
                 }
-                if (!entry.isFile())
-                    continue;
-                const asset = this.loadAsset(urlPath);
-                if (!asset)
-                    continue;
-                this.assetCache.set(urlPath, asset);
+            }
+            catch (error) {
+                console.log("Asset load failed", dir, error);
+                return;
             }
         };
         walk(this.publicRoutePathName, "");
     }
     loadAsset(assetPath) {
+        let fullPath = "";
         try {
-            const fullPath = path_1.default.join(this.publicRoutePathName, assetPath);
+            fullPath = path_1.default.join(this.publicRoutePathName, assetPath);
             const body = fs_1.default.readFileSync(fullPath);
             const size = body.length;
             const ext = path_1.default.extname(assetPath).toLowerCase();
@@ -316,7 +323,8 @@ class WebContext extends HttpContext_1.default {
             const payload = Buffer.concat([headers, body]);
             return { headers, body, size, payload };
         }
-        catch {
+        catch (err) {
+            console.error("Asset load failed:", fullPath, err);
             return undefined;
         }
     }

package/dist/http/response/PipeResponseBase.d.ts

@@ -1,31 +1,112 @@
-import { IHttpResponseBase } from "./HttpResponseBase";
+import { Http } from "../../http";
 /**
- * @class PipeResponseBase
- * @description The base Response class used by Http.
- * This class manages the HTTP response status code, headers, and body.
- * Developers can inherit this class and override methods (e.g., `json`, `getResp`) to create custom response types.
+ * Base HTTP response implementation used internally by the server.
+ *
+ * Responsible for:
+ *  - managing status code
+ *  - storing headers
+ *  - writing body
+ *  - optional compression
+ *  - serializing everything into a raw HTTP Buffer
+ *
+ * This class is optimized for performance and object pooling.
+ *
+ * You may extend this class to implement custom helpers
+ * (e.g. html(), stream(), file(), etc.).
  */
-export declare class PipeResponseBase implements IHttpResponseBase {
+export declare class PipeResponseBase implements Http.IHttpResponseBase {
+    /**
+     * Raw response body stored as UTF-8 string.
+     */
     protected body: string;
+    /**
+     * HTTP status code.
+     * @default 200
+     */
     protected status: number;
+    /**
+     * Response headers map.
+     * Uses Object.create(null) for maximum performance and safety.
+     */
     protected headers: Record<string, string>;
+    /**
+     * Marks whether response has been finalized (send/json/redirect called).
+     */
     protected finishedFlag: boolean;
+    /**
+     * Compression function lookup table.
+     * Example: { gzip: fn, br: fn }
+     */
     protected contentEncodingTable: Record<string, Function>;
+    /**
+     * Selected compression type.
+     */
     protected compression: "gzip" | "br" | "deflate" | null;
+    /**
+     * Object pool identifier.
+     */
     protected objId: number;
+    /**
+     * Reference to response object pool.
+     */
     protected cPool: any;
     constructor();
+    /**
+     * Attaches this response to an object pool.
+     */
     setCPool(cPool: any, objId: number): void;
+    /**
+     * Resets state and returns object back to the pool.
+     */
     freeCPool(): void;
+    /** Returns current HTTP status code. */
     getStatus(): number;
+    /** Returns response headers object. */
     getHeaders(): Record<string, string>;
+    /** Returns response body as string. */
     getBody(): string;
+    /**
+     * Sets HTTP status code.
+     */
     setStatus(code: number): this;
+    /**
+     * Sets a single response header.
+     */
     setHeader(key: string, value: string): this;
+    /**
+     * Merges multiple headers.
+     */
     setHeaders(obj: Record<string, string>): this;
+    /**
+     * Sends plain text payload.
+     * Marks response as finished.
+     */
     send(payload: string): void;
+    /**
+     * Sends JSON response.
+     * Automatically sets Content-Type: application/json.
+     */
     json(obj: unknown): void;
+    /**
+     * Redirects client to another URL.
+     * @default code 302
+     */
     redirect(url: string, code?: number): void;
+    /**
+     * Enables response compression.
+     * Automatically sets Content-Encoding header.
+     */
     setCompression(enc: "gzip" | "br" | "deflate"): this;
+    /**
+     * Serializes the response into a raw HTTP/1.1 buffer.
+     *
+     * Includes:
+     *  - status line
+     *  - headers
+     *  - optional compression
+     *  - content-length
+     *
+     * This is the final step before writing to the socket.
+     */
     getResp(): Buffer;
 }

package/dist/http/response/PipeResponseBase.js

@@ -2,20 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PipeResponseBase = void 0;
 /**
- * @class PipeResponseBase
- * @description The base Response class used by Http.
- * This class manages the HTTP response status code, headers, and body.
- * Developers can inherit this class and override methods (e.g., `json`, `getResp`) to create custom response types.
+ * Base HTTP response implementation used internally by the server.
+ *
+ * Responsible for:
+ *  - managing status code
+ *  - storing headers
+ *  - writing body
+ *  - optional compression
+ *  - serializing everything into a raw HTTP Buffer
+ *
+ * This class is optimized for performance and object pooling.
+ *
+ * You may extend this class to implement custom helpers
+ * (e.g. html(), stream(), file(), etc.).
  */
 class PipeResponseBase {
     constructor() {
+        /**
+         * Raw response body stored as UTF-8 string.
+         */
         this.body = "";
+        /**
+         * HTTP status code.
+         * @default 200
+         */
         this.status = 200;
+        /**
+         * Response headers map.
+         * Uses Object.create(null) for maximum performance and safety.
+         */
         this.headers = Object.create(null);
+        /**
+         * Marks whether response has been finalized (send/json/redirect called).
+         */
         this.finishedFlag = false;
+        /**
+         * Selected compression type.
+         */
         this.compression = null;
+        /**
+         * Object pool identifier.
+         */
         this.objId = -1;
-        // JIT / inline safety
+        // Bind once for JIT/inline stability and faster hot path calls
         Object.defineProperty(this, "getResp", {
             value: this.getResp.bind(this),
             writable: false,
@@ -26,10 +55,16 @@ class PipeResponseBase {
     /* ===================== */
     /* ===== POOL API ====== */
     /* ===================== */
+    /**
+     * Attaches this response to an object pool.
+     */
     setCPool(cPool, objId) {
         this.objId = objId;
         this.cPool = cPool;
     }
+    /**
+     * Resets state and returns object back to the pool.
+     */
     freeCPool() {
         this.body = "";
         this.status = 200;
@@ -41,26 +76,38 @@ class PipeResponseBase {
     /* ===================== */
     /* ===== GETTERS ======= */
     /* ===================== */
+    /** Returns current HTTP status code. */
     getStatus() {
         return this.status;
     }
+    /** Returns response headers object. */
     getHeaders() {
         return this.headers;
     }
+    /** Returns response body as string. */
     getBody() {
         return this.body;
     }
     /* ===================== */
     /* ===== MUTATORS ====== */
     /* ===================== */
+    /**
+     * Sets HTTP status code.
+     */
     setStatus(code) {
         this.status = code | 0;
         return this;
     }
+    /**
+     * Sets a single response header.
+     */
     setHeader(key, value) {
         this.headers[key] = value;
         return this;
     }
+    /**
+     * Merges multiple headers.
+     */
     setHeaders(obj) {
         for (const k in obj)
             this.headers[k] = obj[k];
@@ -69,21 +116,37 @@ class PipeResponseBase {
     /* ===================== */
     /* ===== SEND API ====== */
     /* ===================== */
+    /**
+     * Sends plain text payload.
+     * Marks response as finished.
+     */
     send(payload) {
         this.body = payload;
         this.finishedFlag = true;
     }
+    /**
+     * Sends JSON response.
+     * Automatically sets Content-Type: application/json.
+     */
     json(obj) {
         this.setHeader("Content-Type", "application/json");
         this.body = JSON.stringify(obj);
         this.finishedFlag = true;
     }
+    /**
+     * Redirects client to another URL.
+     * @default code 302
+     */
     redirect(url, code = 302) {
         this.status = code | 0;
         this.headers["Location"] = url;
         this.body = "";
         this.finishedFlag = true;
     }
+    /**
+     * Enables response compression.
+     * Automatically sets Content-Encoding header.
+     */
     setCompression(enc) {
         this.compression = enc;
         this.headers["Content-Encoding"] = enc;
@@ -92,6 +155,17 @@ class PipeResponseBase {
     /* ===================== */
     /* ===== FINALIZE ====== */
     /* ===================== */
+    /**
+     * Serializes the response into a raw HTTP/1.1 buffer.
+     *
+     * Includes:
+     *  - status line
+     *  - headers
+     *  - optional compression
+     *  - content-length
+     *
+     * This is the final step before writing to the socket.
+     */
     getResp() {
         const hdr = { ...this.headers };
         let bodyBuf = Buffer.from(this.body, "utf-8");

package/dist/http.d.ts

@@ -104,148 +104,67 @@ export declare namespace Http {
         FLAG_SMUGGING_TE_CL = 24576
     }
     /**
-     * @interface Server
-     * @description Defines the public methods and properties of the Http server instance.
-     * It is used to configure and manage the server settings and lifecycle.
+     * @interface HttpContext
+     * @description Public API surface of the HTTP runtime context.
+     * Wraps Node.js `net.Server` and provides HTTP features such as
+     * routing, pooling, limits, CORS and lifecycle management.
      */
-    export interface Server {
+    export interface HttpContext {
         /**
-         * @method enableCors
-         * @description Enables and configures Cross-Origin Resource Sharing (CORS) for the server.
-         * @param {CorsConfig} opts - CORS configuration options.
-         * @returns {this} The server instance for chaining.
+         * Underlying raw Node.js server instance.
+         * Can be used for low-level socket/event access when needed.
          */
-        enableCors(opts: CorsConfig): this;
+        readonly server: net.Server;
         /**
-         * @method setTimeout
-         * @description Sets the connection timeout value.
-         * @param {number} timeout - Timeout duration in milliseconds. Must be greater than 0.
+         * Enables and configures Cross-Origin Resource Sharing (CORS).
+         *
+         * Automatically injects CORS headers into responses.
+         *
+         * @returns {this} Context instance (chainable)
          */
-        setTimeout(timeout: number): void;
+        enableCors(cfg: CorsConfig): this;
         /**
-         * @method setRequestQuerySize
-         * @description Sets the maximum allowed size for the request query string.
-         * @param {number} requestQuerySize - Maximum query string size in bytes. Must be greater than 0.
+         * Sets the connection timeout.
+         * @default 3000 ms
          */
-        setRequestQuerySize(requestQuerySize: number): void;
+        setTimeout(timeout: number): void;
         /**
-         * @method setMaxHeaderSize
-         * @description Sets the maximum allowed size for request headers.
-         * @param {number} maxHeaderSize - Maximum header size in bytes. Must be greater than 0.
+         * Sets the maximum allowed query string size.
+         * @default 2048 bytes
          */
-        setMaxHeaderSize(maxHeaderSize: number): void;
+        setRequestQuerySize(requestQuerySize: number): void;
         /**
-         * @method setMaxContentSize
-         * @description Sets the maximum allowed size for the request body (content/payload).
-         * @param {number} maxContentSize - Maximum content size in bytes. Must be greater than 0.
+         * Sets the maximum allowed request body (payload) size.
+         * @default 3145728 bytes (3MB)
          */
         setMaxContentSize(maxContentSize: number): void;
         /**
-         * @method getTimeout
-         * @description Gets the current connection timeout value.
-         * @returns {number} The timeout duration in milliseconds.
+         * Sets the max header name size.
+         * @default 512 bytes
          */
-        getTimeout(): number;
+        setMaxHeaderNameSize(maxHeaderNameSize: number): void;
         /**
-         * @method getRequestQuerySize
-         * @description Gets the current maximum request query string size.
-         * @returns {number} The maximum query string size in bytes.
+         * Sets the max header value size.
+         * @default 1024 bytes
          */
+        setMaxHeaderValueSize(maxHeaderValueSize: number): void;
+        getTimeout(): number;
         getRequestQuerySize(): number;
-        /**
-         * @method getMaxHeaderSize
-         * @description Gets the current maximum request header size.
-         * @returns {number} The maximum header size in bytes.
-         */
-        getMaxHeaderSize(): number;
-        /**
-         * @method getMaxContentSize
-         * @description Gets the current maximum request content size.
-         * @returns {number} The maximum content size in bytes.
-         */
+        getMaxHeaderNameSize(): number;
+        getMaxHeaderValueSize(): number;
         getMaxContentSize(): number;
         /**
-         * @property {boolean} listening
-         * @description A boolean indicating whether or not the server is listening for connections.
-         */
-        listening: boolean;
-        /**
-         * @method listen
-         * @description Starts the server listening for connections.
-         * @param {number} [port] - The port to listen on.
-         * @param {string} [hostname] - The host name or IP address to listen on.
-         * @param {() => void} [listeningListener] - Callback function once the server starts listening.
-         * @param {number} [backlog] - The maximum length of the queue of pending connections.
-         * @returns {this} The server instance for chaining.
-         */
-        listen(port?: number, hostname?: string, listeningListener?: () => void, backlog?: number): this;
-        /**
-         * @method address
-         * @description Returns the bound address, address family name, and port of the server.
-         * @returns {net.AddressInfo | string | null} The address info.
-         */
-        address(): net.AddressInfo | string | null;
-        /**
-         * @method setMaxRequests
-         * @description Sets the maximum number of concurrent requests the server can handle by resizing internal pools.
-         * @param {number} n - The maximum number of concurrent requests. Must be 1 or greater.
-         * @returns {boolean} Returns `true` if the pools were successfully resized, `false` otherwise.
-         */
-        setMaxRequests: (n: number) => boolean;
-        /**
-         * @method getMaxListeners
-         * @description Gets the current maximum listener value.
-         * @returns {number} The maximum number of listeners.
+         * Starts listening for incoming connections.
+         * @returns {this} Context instance (chainable)
          */
-        getMaxListeners(): number;
+        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
         /**
-         * @method setMaxListeners
-         * @description Sets the max number of listeners.
-         * @param {number} n - The maximum number of listeners.
-         * @returns {this} The server instance for chaining.
+         * Sets maximum number of concurrent requests.
+         * Resizes internal pools.
+         *
+         * @default 5000
          */
-        setMaxListeners(n: number): this;
-        /**
-         * @method on
-         * @description Registers an event listener for the 'close' event.
-         */
-        on(event: 'close', listener: () => void): this;
-        /**
-         * @method on
-         * @description Registers an event listener for the 'connection' event.
-         */
-        on(event: 'connection', listener: (socket: net.Socket) => void): this;
-        /**
-         * @method on
-         * @description Registers an event listener for the 'error' event.
-         */
-        on(event: 'error', listener: (err: Error) => void): this;
-        /**
-         * @method on
-         * @description Registers an event listener for the 'listening' event.
-         */
-        on(event: 'listening', listener: () => void): this;
-        /**
-         * @method on
-         * @description Registers a listener for any specified event.
-         * @param {string} event - The name of the event.
-         * @param {Function} listener - The callback function.
-         */
-        on(event: string, listener: (...args: any[]) => void): this;
-        /**
-         * @method off
-         * @description Removes a registered listener for the specified event.
-         * @param {string} event - The name of the event.
-         * @param {Function} listener - The callback function to remove.
-         */
-        off(event: string, listener: (...args: any[]) => void): this;
-        /**
-         * @method close
-         * @description Stops the server from accepting new connections and keeps existing connections.
-         * @param {(err?: Error) => void} [callback] - Called when the server has closed.
-         * @returns {this} The server instance for chaining.
-         */
-        close(callback?: (err?: Error) => void): this;
+        setMaxRequests(n: number): boolean;
     }
     /**
      * @description Represents a map of pre-defined HTTP response buffers for common errors and status codes.
@@ -304,31 +223,70 @@ export declare namespace Http {
         maxAge?: number;
     }
     /**
-     * @interface ServerOptions
-     * @description Options used to configure the behavior of the Http server.
-     * @property {net.ServerOpts} netServerOptions - Options passed to the underlying Node.js net.Server structure.
-     * @property {number} [maxHeaderSize=2048] - The maximum allowed request header size (bytes). (Recommended: 2048 - 4096)
-     * @property {number} [maxContentSize=3145728] - The maximum allowed request content/payload size (bytes). (Recommended: 1MB - 10MB)
-     * @property {number} [timeout=0] - Socket timeout duration (milliseconds). (3000: No timeout)
-     * @property {boolean} [untilEnd=false] - Determines if the server should wait for the end of the stream when Content-Length or Transfer-Encoding are not specified.
-     * If `false` and these headers are missing, the request is closed immediately and ignored (Default behavior).
-     * If `true`, it waits until the end of the stream.
-     * @property {number} [maxRequests=5000] - The maximum number of simultaneous requests/connections that can be processed. Also determines the pool size. (Recommended: 5000 - 10000)
-     * @property {typeof PipeResponseBase} ResponseCtor - The constructor function for the custom Response class to be used for requests.
-     * Can be used by extending `PipeResponseBase` to add your own custom response types (e.g., for JSON, XML, etc.).
-     * @property {number} [requestQuerySize=2048] - The maximum allowed request query string size (bytes). (Recommended: 1024 - 4096)
-     */
+ * Configuration options used to initialize the HTTP context/server.
+ */
     export interface ServerOptions {
+        /**
+         * Options forwarded directly to the underlying Node.js `net.Server`.
+         */
         netServerOptions?: net.ServerOpts;
+        /**
+         * Maximum total header size in bytes.
+         * @default 2048
+         * @recommended 2048 – 4096
+         */
         maxHeaderSize?: number;
+        /**
+         * Maximum allowed header name size in bytes.
+         * @default 256
+         */
         maxHeaderNameSize?: number;
+        /**
+         * Maximum allowed header value size in bytes.
+         * @default 2048
+         */
         maxHeaderValueSize?: number;
+        /**
+         * Maximum allowed request body (payload) size in bytes.
+         * @default 3145728 (3MB)
+         * @recommended 1MB – 10MB
+         */
         maxContentSize?: number;
+        /**
+         * Socket timeout duration in milliseconds.
+         * 0 disables timeout.
+         * @default 3000
+         */
         timeout?: number;
+        /**
+         * Determines behavior when `Content-Length` or `Transfer-Encoding` is missing.
+         *
+         * false → close immediately
+         * true → wait until stream ends
+         *
+         * @default false
+         */
         untilEnd?: boolean;
+        /**
+         * Maximum number of concurrent requests/connections.
+         * Also defines internal pool size.
+         * @default 5000
+         * @recommended 5000 – 10000
+         */
         maxRequests?: number;
+        /**
+         * Custom response constructor.
+         * Extend `PipeResponseBase` to implement JSON/XML/custom responses.
+         */
         ResponseCtor?: typeof PipeResponseBase;
+        /**
+         * Callback triggered when a new pool chunk is created during bootstrap.
+         */
         bootstrapPoolChunkProgression?: (createdChunkProgression: ChunkProgression) => void;
+        /**
+         * Maximum allowed request query string size in bytes.
+         * @default 2048
+         */
         requestQuerySize?: number;
     }
     /**
@@ -360,42 +318,122 @@ export declare namespace Http {
         handle: MiddlewareHandleFn;
     }
     export type AccumulateHandleFn = (socket: net.Socket, p: ChunkProgression) => void;
+    /**
+     * Represents a single HTTP endpoint bound to a specific route + method.
+     * Contains handler, middleware chain and per-endpoint limits.
+     */
     export interface Endpoint {
+        /**
+         * URL path segment of the endpoint.
+         * Example: "/users", "/:id"
+         */
         url: string;
+        /**
+         * HTTP method handled by this endpoint.
+         */
         method: HttpMethod;
+        /**
+         * Optional content configuration (type/encoding rules).
+         */
         ct?: ContentConfig;
+        /**
+         * Optional custom accumulate handler used during request parsing.
+         * Overrides default accumulation behavior.
+         */
         accumulateHandle?: AccumulateHandleFn;
+        /**
+         * Middleware chain executed before the main handler.
+         */
         middlewares: Middleware[];
+        /**
+         * Adds a middleware to this endpoint.
+         * @returns {Endpoint} same endpoint (chainable)
+         */
         addMiddleware(mw: Middleware): Endpoint;
+        /**
+         * Main request handler function.
+         */
         handle: EndpointHandleFn | any;
+        /**
+         * If true, waits until stream end even if
+         * `Content-Length` / `Transfer-Encoding` is missing.
+         *
+         * Overrides global server setting.
+         * @default false
+         */
         untilEnd?: boolean;
+        /**
+         * Maximum request body size allowed for this endpoint.
+         * Overrides global server limit.
+         */
         maxContentSize?: number;
+        /**
+         * Maximum header size allowed for this endpoint.
+         * Overrides global server limit.
+         */
         maxHeaderSize?: number;
     }
+    /**
+     * Optional per-endpoint configuration overrides.
+     * Used when creating endpoints to customize limits locally.
+     */
     export interface EndpointOpt {
+        /**
+         * Overrides global `untilEnd` behavior.
+         * @default false
+         */
         untilEnd?: boolean;
+        /**
+         * Overrides global maximum content size.
+         */
         maxContentSize?: number;
+        /**
+         * Overrides global maximum header size.
+         */
         maxHeaderSize?: number;
     }
     /**
-     * @interface Route
-     * @description Defines a routing structure for the Http server.
-     * It is the basic building block of the routing tree.
-     * @property {string} url - The URL path segment this route will match (e.g., '/users').
-     * @property {Endpoint[]} endpoints - Endpoints corresponding to HTTP methods for this route.
-     * @property {Middleware[]} middlewares - Middleware functions to run for requests to this route and its sub-routes.
-     * @property {Route[]} routes - Nested sub-routes under this route.
-     * @method addRoute - Adds a new sub-route.
-     * @method addEndpoint - Adds a new endpoint.
-     * @method addMiddleware - Adds a new middleware.
+     * Represents a routing node in the HTTP routing tree.
+     *
+     * A route can:
+     * - contain endpoints
+     * - contain middlewares
+     * - contain nested sub-routes
+     *
+     * Works similar to Express/Fastify router groups.
      */
     export interface Route {
+        /**
+         * Base URL path segment for this route.
+         * Example: "/users"
+         */
         url: string;
+        /**
+         * Endpoints registered for this route.
+         */
         endpoints: Endpoint[];
+        /**
+         * Middlewares applied to this route and all child routes.
+         */
         middlewares: Middleware[];
+        /**
+         * Nested child routes.
+         */
         routes: Route[];
+        /**
+         * Adds a child route.
+         * @returns {Route} same route (chainable)
+         */
         addRoute(r: Route): Route;
+        /**
+         * Adds an endpoint to this route.
+         * @returns {Route} same route (chainable)
+         */
         addEndpoint(ep: Endpoint): Route;
+        /**
+         * Adds a middleware to this route.
+         * @returns {Route} same route (chainable)
+         */
         addMiddleware(mw: Middleware): Route;
     }
     export interface BuildedRoute {
@@ -440,26 +478,100 @@ export declare namespace Http {
         br = "br",
         deflate = "deflate"
     }
+    /**
+     * Defines content negotiation and parsing rules for an endpoint.
+     *
+     * Controls how request bodies are interpreted and decoded
+     * based on Content-Type and Content-Encoding headers.
+     */
     export interface ContentConfig {
-        type: ContentTypeTables | null | undefined;
-        encoding: ContentEncodingTables | null | undefined;
+        /**
+         * Expected content type of the request body.
+         *
+         * If undefined → any type is accepted.
+         */
+        type?: ContentTypeTables | null;
+        /**
+         * Expected content encoding (gzip, br, deflate, etc.).
+         *
+         * If undefined → no decoding is applied.
+         */
+        encoding?: ContentEncodingTables | null;
     }
+    /**
+     * Internal compiled route representation used at runtime.
+     *
+     * Created after the routing tree is built.
+     * Contains fully prepared handlers, middleware chain and limits
+     * for fast request dispatching.
+     */
     export interface RoutePipe {
+        /**
+         * Function responsible for accumulating and parsing
+         * incoming socket data into a request.
+         */
         accumulateHandler(socket: net.Socket, chunkProgression: ChunkProgression): void;
+        /**
+         * Full normalized route URL.
+         * Example: "/users/:id"
+         */
         url: string;
+        /**
+         * Optional content configuration for this route.
+         */
         ct?: ContentConfig;
+        /**
+         * Precompiled pipeline handler (middlewares + endpoint handler).
+         */
         pipeHandler: Function;
+        /**
+         * Ordered middleware handlers executed before the endpoint.
+         */
         mws: Http.MiddlewareHandleFn[];
+        /**
+         * Response constructor used to create response objects
+         * for this route.
+         */
         ResponseCtor: typeof PipeResponseBase;
+        /**
+         * Internal route identifier (used for fast lookup/dispatch).
+         */
         routeId: number;
+        /**
+         * Determines whether to wait for stream end when
+         * Content-Length / Transfer-Encoding is missing.
+         */
         untilEnd: boolean;
+        /**
+         * Maximum allowed request body size in bytes for this route.
+         */
         maxContentSize: number;
+        /**
+         * Maximum allowed header size in bytes for this route.
+         */
         maxHeaderSize: number;
     }
     export type ParseInitialFn = (socket: net.Socket, chunk: Buffer, p: Http.ChunkProgression) => void;
+    /**
+     * Configuration options for the Web HTTP context.
+    */
     export interface WebContextState {
+        /**
+         * Physical folder name where static files are served from.
+         * @default "dist"
+         * @example "./dist", "./build", "./public"
+        */
         publicStaticPath?: string;
+        /**
+         * URL route prefix for static assets.
+         * @default "/public"
+         * @example "/assets" -> http://host/assets/logo.png
+        */
         publicStaticRoute?: string;
+        /**
+         * Entry HTML file for SPA fallback (used when route not found).
+         * @default "dist/index.html"
+        */
         spaRootPath?: string;
     }
     /**
@@ -563,5 +675,29 @@ export declare namespace Http {
          */
         chunkParser: ChunkParser;
     }
+    /**
+     * Minimal public contract for a response object.
+     *
+     * Allows setting headers, status and sending content,
+     * then serializing into a raw HTTP buffer.
+     */
+    export interface IHttpResponseBase {
+        /** Sets HTTP status code. */
+        setStatus(code: number): this;
+        /** Sets a single header. */
+        setHeader(key: string, value: string): this;
+        /** Sets multiple headers at once. */
+        setHeaders(obj: Record<string, string>): this;
+        /** Sends plain text payload. */
+        send(payload: string): void;
+        /** Sends JSON payload. */
+        json(obj: unknown): void;
+        /** Sends redirect response. */
+        redirect(url: string, code?: number): void;
+        /** Produces raw HTTP buffer for socket write. */
+        getResp(): Buffer;
+        /** Releases object back to pool. */
+        freeCPool(): void;
+    }
     export {};
 }

package/dist/index.d.ts

@@ -7,3 +7,13 @@ declare function createServer(opts?: Http.ServerOptions): {
 };
 export { createServer };
 export * from "./http";
+export * as Factory from "./http/factory/factory";
+export * as Pipeline from "./http/factory/pipeline";
+export * as Accumulator from "./http/factory/accumulator";
+export * as Content from "./http/content/encoding";
+export { contentParserTable } from "./http/content/parser";
+export * as Chunker from "./http/chunker/ChunkParser";
+export * as ChunkProgression from "./http/chunker/ChunkProgression";
+export * as Streaming from "./http/chunker/StreamingChunkedParser";
+export * as Fixed from "./http/chunker/FixedChunkedParser";
+export * as UntilEnd from "./http/chunker/UntilEndChunkerParser";

package/dist/index.js

@@ -10,13 +10,36 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UntilEnd = exports.Fixed = exports.Streaming = exports.ChunkProgression = exports.Chunker = exports.contentParserTable = exports.Content = exports.Accumulator = exports.Pipeline = exports.Factory = void 0;
 exports.createServer = createServer;
 const WebContext_1 = __importDefault(require("./http/context/WebContext"));
 const ApiContext_1 = __importDefault(require("./http/context/ApiContext"));
@@ -36,4 +59,27 @@ function createServer(opts) {
         }
     };
 }
+// ================================
+// Core types (main public API)
+// ================================
 __exportStar(require("./http"), exports);
+// ================================
+// Factories / Builders
+// ================================
+exports.Factory = __importStar(require("./http/factory/factory"));
+exports.Pipeline = __importStar(require("./http/factory/pipeline"));
+exports.Accumulator = __importStar(require("./http/factory/accumulator"));
+// ================================
+// Content layer
+// ================================
+exports.Content = __importStar(require("./http/content/encoding"));
+var parser_1 = require("./http/content/parser");
+Object.defineProperty(exports, "contentParserTable", { enumerable: true, get: function () { return parser_1.contentParserTable; } });
+// ================================
+// Low-level engine (advanced users)
+// ================================
+exports.Chunker = __importStar(require("./http/chunker/ChunkParser"));
+exports.ChunkProgression = __importStar(require("./http/chunker/ChunkProgression"));
+exports.Streaming = __importStar(require("./http/chunker/StreamingChunkedParser"));
+exports.Fixed = __importStar(require("./http/chunker/FixedChunkedParser"));
+exports.UntilEnd = __importStar(require("./http/chunker/UntilEndChunkerParser"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corecdtl",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "High-performance customizable HTTP engine",
   "license": "MIT",
   "main": "dist/index.js",
@@ -13,12 +13,15 @@
     "engine",
     "native",
     "addon",
-    "low-level"
+    "low-level",
+    "fast",
+    "corecdtl"
   ],
   "scripts": {
     "build": "node-gyp rebuild && rm -rf dist && tsc",
     "install": "node-gyp-build",
     "prebuild": "prebuildify --napi --strip",
+    "build-ts": "tsc",
     "test": "vitest run",
     "benchmark": "node benchmark/e2e/run.js",
     "prepublishOnly": "npm run build",
@@ -56,5 +59,5 @@
   "bugs": {
     "url": "https://github.com/DirikTi/corecdtl/issues"
   },
-  "homepage": "https://github.com/DirikTi/corecdtl#readme"
+  "homepage": "https://github.com/DirikTi/corecdtl#quickstart"
 }

package/dist/http/response/HttpResponseBase.d.ts

@@ -1,10 +0,0 @@
-export interface IHttpResponseBase {
-    setStatus(code: number): this;
-    setHeader(key: string, value: string): this;
-    setHeaders(obj: Record<string, string>): this;
-    send(payload: string): void;
-    json(obj: unknown): void;
-    redirect(url: string, code?: number): void;
-    getResp(): Buffer;
-    freeCPool(): void;
-}

package/dist/http/response/HttpResponseBase.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });