corecdtl 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [DirikTi]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+<p align="center">
+  <img src="docs/assets/logo.png" alt="<Project Name> Logo" width="180"/>
+</p>
+
+<h1 align="center"><CoreCDTL></h1>
+
+<p align="center">
+  <a href="<CI_LINK>">
+    <img src="https://img.shields.io/badge/build-passing-brightgreen" />
+  </a>
+  <a href="<TEST_LINK>">
+    <img src="https://img.shields.io/badge/tests-rfc-blue" />
+  </a>
+  <a href="<LICENSE_LINK>">
+    <img src="https://img.shields.io/badge/license-MIT-black" />
+  </a>
+  <img src="https://img.shields.io/badge/HTTP-1.1-orange" />
+  <img src="https://img.shields.io/badge/SIMD-required-red" />
+  <a href="<API_DOCS_LINK>">
+    <img src="https://img.shields.io/badge/docs-API-informational" />
+  </a>
+</p>
+
+<p align="center">
+  High-performance • Low-level • Fully customizable HTTP engine
+</p>
+
+# CoreCDTL
+
+**A high-performance, fully customizable HTTP engine for building web and API servers.**
+
+Designed for teams that need maximum control over their HTTP stack without sacrificing performance.
+Suitable for large-scale, high-traffic production systems and internal infrastructure.
+
+---
+
+# Overview
+
+`CoreCDTL` is a low-level HTTP engine distributed as a **library**, not a framework.
+
+It operates above the socket layer and provides more than just parsing.
+Beyond request parsing, it includes a full processing pipeline that enables building complete HTTP servers with deep customization.
+
+The engine allows developers to intervene and replace core behaviors such as:
+
+* request accumulation
+* response models
+* content parsers
+* pipeline stages
+
+This makes it ideal for teams that want to design and control their own architecture instead of adapting to opinionated frameworks.
+
+---
+
+# Design Goals
+
+* High performance
+* Minimal overhead parsing
+* Deterministic state machines
+* Fully customizable request/response pipeline
+* Pluggable internal components
+* Production-grade reliability
+* Designed for large-scale and high-traffic systems
+* Suitable for web and API servers
+
+---
+
+# Architecture
+
+## High-Level Architecture
+
+```
+Socket → Parser → State Machines → Pipeline → Handlers → Response
+```
+
+The engine processes data in a single pass and drives the request lifecycle through explicit states and a customizable execution pipeline.
+
+---
+
+## State Machines
+
+The HTTP protocol is handled using deterministic state machines:
+
+* Request line
+* Headers
+* Body
+* Chunked transfer encoding
+
+This approach ensures:
+
+* predictable behavior
+* low branching overhead
+* high cache efficiency
+* safe incremental parsing
+
+---
+
+## Customization Points
+
+The engine is designed to be extended or replaced at multiple levels:
+
+* Accumulators
+* Response models
+* Content parsers
+* Pipeline stages / middleware
+* Server behavior customization
+
+Users can build their own HTTP server behavior on top of the core engine without modifying internals.
+
+---
+
+# RFC Compliance
+
+The engine follows the HTTP/1.1 specifications and validates protocol rules strictly.
+
+* RFC-compliant parsing
+* Strict header validation
+* Deterministic behavior on malformed input
+* Non-compliant or ambiguous inputs are intentionally rejected
+
+---
+
+# Security Considerations
+
+Security is handled as a first-class concern.
+
+The engine includes protections against:
+
+* header injection
+* CRLF attacks
+* request smuggling vectors
+* malformed or ambiguous requests
+* unsafe parsing states
+
+Invalid inputs fail fast and do not propagate undefined behavior.
+
+---
+
+# Performance Characteristics
+
+The engine is built with performance as a core principle:
+
+* single-pass parsing
+* low/zero-copy design
+* minimal allocations
+* cache-friendly structures
+* branch-predictable state machines
+* SIMD optimizations
+
+Designed for high-throughput, low-latency workloads.
+
+---
+
+# Public API
+
+Full API documentation is available here:
+
+👉 **[API Documentation](https://corecdtl.com/docs/intro)**
+
+---
+
+# Testing
+
+The project includes:
+
+* Unit tests
+* RFC compliance tests
+
+---
+
+# Platform Support
+
+Requires modern CPUs with **SIMD support**.
+
+---
+
+# Limitations
+
+See:
+
+👉 **[Limitations](https://corecdtl.com/docs/limitations)**
+
+
+Current known limitations include:
+
+* HTTP/2 not supported
+* TLS not included
+
+---
+
+# Roadmap
+
+Planned features and future work:
+
+👉 **[Roadmap](https://corecdtl.com/docs/roadmap)**
+
+---
+
+# License
+
+Open-source.
+See **[LICENSE](LICENSE)** for details.

package/dist/http/chunker/ChunkParser.d.ts

@@ -0,0 +1,8 @@
+import FixedChunkedParser from "./FixedChunkedParser";
+import StreamingChunkedParser from "./StreamingChunkedParser";
+import { UntilEndChunkedParser } from "./UntilEndChunkerParser";
+export interface ChunkParser {
+    streaming: StreamingChunkedParser;
+    fixed: FixedChunkedParser;
+    untilEnd: UntilEndChunkedParser;
+}

package/dist/http/chunker/ChunkParser.js

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

package/dist/http/chunker/ChunkProgression.d.ts

@@ -0,0 +1,25 @@
+import { ChunkParser } from "./ChunkParser";
+import { Http } from "../../http";
+declare class ChunkProgression {
+    objId: number;
+    fn: Function;
+    chunkParser: ChunkParser;
+    contentLen?: number;
+    routePipe: any;
+    params: string[];
+    headers: Record<string, string | Array<string>>;
+    query: any;
+    method: Http.HttpMethod;
+    headerSize: number;
+    mainOffset: number;
+    retFlag: number;
+    rawBuf: Buffer;
+    private respCpool;
+    private cPool;
+    private parseInitial;
+    constructor(cPool: any, parseInitial: Function, respCpool: any);
+    allocateResp(): any;
+    reset(): void;
+    free(): void;
+}
+export default ChunkProgression;

package/dist/http/chunker/ChunkProgression.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("../../http");
+const FixedChunkedParser_1 = __importDefault(require("./FixedChunkedParser"));
+const StreamingChunkedParser_1 = __importDefault(require("./StreamingChunkedParser"));
+const UntilEndChunkerParser_1 = require("./UntilEndChunkerParser");
+class ChunkProgression {
+    constructor(cPool, parseInitial, respCpool) {
+        this.cPool = cPool;
+        this.fn = parseInitial;
+        this.chunkParser = {
+            streaming: new StreamingChunkedParser_1.default(),
+            fixed: new FixedChunkedParser_1.default(),
+            untilEnd: new UntilEndChunkerParser_1.UntilEndChunkedParser()
+        };
+        this.contentLen = undefined;
+        this.routePipe = null;
+        this.params = [];
+        this.headers = {};
+        this.query = {};
+        this.method = http_1.Http.HttpMethod.GET;
+        this.headerSize = 0;
+        this.mainOffset = 0;
+        this.retFlag = http_1.Http.RetFlagBits.FLAG_OK;
+        this.rawBuf = Buffer.allocUnsafe(0);
+        this.objId = cPool.registerObj(this);
+        this.respCpool = respCpool;
+        this.parseInitial = parseInitial;
+    }
+    allocateResp() {
+        let ret = this.respCpool.allocate();
+        return ret;
+    }
+    reset() {
+        this.fn = this.parseInitial;
+        this.contentLen = undefined;
+        this.routePipe = null;
+        this.params = [];
+        this.headers = {};
+        this.query = {};
+        this.method = http_1.Http.HttpMethod.GET;
+        this.headerSize = 0;
+        this.mainOffset = 0;
+        this.retFlag = http_1.Http.RetFlagBits.FLAG_OK;
+        this.rawBuf = Buffer.allocUnsafe(0);
+    }
+    free() {
+        this.reset();
+        this.cPool.free(this.objId);
+    }
+}
+exports.default = ChunkProgression;

package/dist/http/chunker/FixedChunkedParser.d.ts

@@ -0,0 +1,14 @@
+declare class FixedChunkedParser {
+    private buffer;
+    private writeCursor;
+    private expectedLength;
+    constructor();
+    allocateBuffer(size: number): void;
+    write(data: Buffer): void;
+    isFinished(): boolean;
+    getBody(): Buffer;
+    getTotalWrittenSize(): number;
+    getExpectedSize(): number;
+    free(): void;
+}
+export default FixedChunkedParser;

package/dist/http/chunker/FixedChunkedParser.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FixedChunkedParser {
+    constructor() {
+        this.buffer = null;
+        this.writeCursor = 0;
+        this.expectedLength = 0;
+    }
+    allocateBuffer(size) {
+        if (size <= 0) {
+            this.buffer = Buffer.alloc(0);
+            this.expectedLength = 0;
+            return;
+        }
+        this.expectedLength = size;
+        this.buffer = Buffer.allocUnsafe(size);
+        this.writeCursor = 0;
+    }
+    write(data) {
+        if (!this.buffer) {
+            throw new Error("Accumulator not initialized. Call allocateBuffer first.");
+        }
+        const remainingSpace = this.expectedLength - this.writeCursor;
+        const dataLength = data.length;
+        if (dataLength > remainingSpace) {
+            throw new Error(`Fixed buffer overflow: Received ${dataLength} bytes, only ${remainingSpace} remaining.`);
+        }
+        data.copy(this.buffer, this.writeCursor);
+        this.writeCursor += dataLength;
+    }
+    isFinished() {
+        return this.writeCursor === this.expectedLength;
+    }
+    getBody() {
+        return this.buffer || Buffer.alloc(0);
+    }
+    getTotalWrittenSize() {
+        return this.writeCursor;
+    }
+    getExpectedSize() {
+        return this.expectedLength;
+    }
+    free() {
+        this.buffer = null;
+        this.writeCursor = 0;
+        this.expectedLength = 0;
+    }
+}
+exports.default = FixedChunkedParser;

package/dist/http/chunker/StreamingChunkedParser.d.ts

@@ -0,0 +1,19 @@
+declare class StreamingChunkedParser {
+    private residualBuffer;
+    private state;
+    private expected;
+    private bodyParts;
+    private totalSize;
+    constructor();
+    write(data: Buffer): void;
+    /**
+     * Mark the parser as finished. This is optional: external HTTP logic
+     * may simply stop calling `.write()` after the stream ends.
+     */
+    finish(): void;
+    isFinished(): boolean;
+    getBody(): Buffer;
+    getTotalSize(): Number;
+    free(): void;
+}
+export default StreamingChunkedParser;

package/dist/http/chunker/StreamingChunkedParser.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var StreamingChunkedState;
+(function (StreamingChunkedState) {
+    StreamingChunkedState[StreamingChunkedState["READ_SIZE"] = 0] = "READ_SIZE";
+    StreamingChunkedState[StreamingChunkedState["READ_DATA"] = 1] = "READ_DATA";
+    StreamingChunkedState[StreamingChunkedState["READ_CRLF"] = 2] = "READ_CRLF";
+    StreamingChunkedState[StreamingChunkedState["FINISHED"] = 3] = "FINISHED";
+})(StreamingChunkedState || (StreamingChunkedState = {}));
+class StreamingChunkedParser {
+    constructor() {
+        this.residualBuffer = null;
+        this.state = StreamingChunkedState.READ_SIZE;
+        this.expected = 0;
+        this.bodyParts = [];
+        this.totalSize = 0;
+    }
+    write(data) {
+        let currentBuffer;
+        if (this.residualBuffer) {
+            currentBuffer = Buffer.concat([this.residualBuffer, data]);
+            this.residualBuffer = null;
+        }
+        else {
+            currentBuffer = data;
+        }
+        let readIndex = 0;
+        const writeIndex = currentBuffer.length;
+        // 2. State Machine (Sadece currentBuffer üzerinde ilerler)
+        while (readIndex < writeIndex && this.state !== StreamingChunkedState.FINISHED) {
+            const available = writeIndex - readIndex;
+            if (this.state === StreamingChunkedState.READ_SIZE) {
+                // Sadece mevcut Buffer'ın sınırı içinde \r\n ara
+                const idx = currentBuffer.indexOf('\r\n', readIndex);
+                if (idx === -1 || idx >= writeIndex)
+                    break;
+                // Hex boyutu çıkar
+                const hexSize = currentBuffer.toString('ascii', readIndex, idx);
+                this.expected = parseInt(hexSize, 16);
+                readIndex = idx + 2;
+                if (this.expected === 0) {
+                    this.state = StreamingChunkedState.FINISHED;
+                    break;
+                }
+                this.state = StreamingChunkedState.READ_DATA;
+            }
+            if (this.state === StreamingChunkedState.READ_DATA) {
+                if (available < this.expected)
+                    break;
+                const chunk = currentBuffer.subarray(readIndex, readIndex + this.expected);
+                this.bodyParts.push(chunk);
+                this.totalSize += chunk.length;
+                readIndex += this.expected;
+                this.state = StreamingChunkedState.READ_CRLF;
+            }
+            if (this.state === StreamingChunkedState.READ_CRLF) {
+                if (available < 2)
+                    break;
+                readIndex += 2;
+                this.expected = 0;
+                this.state = StreamingChunkedState.READ_SIZE;
+            }
+        }
+        if (readIndex < writeIndex) {
+            this.residualBuffer = currentBuffer.subarray(readIndex);
+        }
+        else {
+            this.residualBuffer = null;
+        }
+    }
+    /**
+     * Mark the parser as finished. This is optional: external HTTP logic
+     * may simply stop calling `.write()` after the stream ends.
+     */
+    finish() {
+    }
+    isFinished() {
+        return this.state === StreamingChunkedState.FINISHED;
+    }
+    getBody() {
+        return Buffer.concat(this.bodyParts, this.totalSize);
+    }
+    getTotalSize() {
+        return this.totalSize;
+    }
+    free() {
+        this.residualBuffer = null;
+        this.state = StreamingChunkedState.READ_SIZE;
+        this.expected = 0;
+        this.bodyParts.length = 0;
+        this.totalSize = 0;
+    }
+}
+exports.default = StreamingChunkedParser;

package/dist/http/chunker/UntilEndChunkerParser.d.ts

@@ -0,0 +1,37 @@
+export declare class UntilEndChunkedParser {
+    private bodyParts;
+    private totalSize;
+    private finished;
+    constructor();
+    /**
+     * Appends incoming data to the internal buffer list.
+     * This method performs zero validation and assumes that
+     * all data belongs to the body until the stream terminates.
+     *
+     * @param {Buffer} data - Raw incoming bytes.
+     */
+    write(data: Buffer): void;
+    /**
+     * Mark the parser as finished. This is optional: external HTTP logic
+     * may simply stop calling `.write()` after the stream ends.
+     */
+    finish(): void;
+    /**
+     * Returns true only if `.finish()` was explicitly called.
+     * Streaming HTTP readers normally won't call this; instead,
+     * they treat socket-close as the terminal event.
+     */
+    isFinished(): boolean;
+    /**
+     * Returns the full concatenated body buffer.
+     */
+    getBody(): Buffer;
+    /**
+     * Returns number of bytes accumulated so far.
+     */
+    getTotalSize(): number;
+    /**
+     * Reset the parser to initial state.
+     */
+    free(): void;
+}

package/dist/http/chunker/UntilEndChunkerParser.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UntilEndChunkedParser = void 0;
+class UntilEndChunkedParser {
+    constructor() {
+        this.bodyParts = [];
+        this.totalSize = 0;
+        this.finished = false;
+    }
+    /**
+     * Appends incoming data to the internal buffer list.
+     * This method performs zero validation and assumes that
+     * all data belongs to the body until the stream terminates.
+     *
+     * @param {Buffer} data - Raw incoming bytes.
+     */
+    write(data) {
+        if (this.finished) {
+            throw new Error("Cannot write after parser is finished.");
+        }
+        if (data.length > 0) {
+            this.bodyParts.push(data);
+            this.totalSize += data.length;
+        }
+    }
+    /**
+     * Mark the parser as finished. This is optional: external HTTP logic
+     * may simply stop calling `.write()` after the stream ends.
+     */
+    finish() {
+        this.finished = true;
+    }
+    /**
+     * Returns true only if `.finish()` was explicitly called.
+     * Streaming HTTP readers normally won't call this; instead,
+     * they treat socket-close as the terminal event.
+     */
+    isFinished() {
+        return this.finished;
+    }
+    /**
+     * Returns the full concatenated body buffer.
+     */
+    getBody() {
+        if (this.bodyParts.length === 0)
+            return Buffer.alloc(0);
+        return Buffer.concat(this.bodyParts, this.totalSize);
+    }
+    /**
+     * Returns number of bytes accumulated so far.
+     */
+    getTotalSize() {
+        return this.totalSize;
+    }
+    /**
+     * Reset the parser to initial state.
+     */
+    free() {
+        this.bodyParts.length = 0;
+        this.totalSize = 0;
+        this.finished = false;
+    }
+}
+exports.UntilEndChunkedParser = UntilEndChunkedParser;

package/dist/http/content/encoding.d.ts

@@ -0,0 +1,3 @@
+import { Http } from "../../http";
+export declare const contentDecodingTable: Http.ContentDecoding;
+export declare const contentEncodingTable: Http.ContentEncoding;

package/dist/http/content/encoding.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentEncodingTable = exports.contentDecodingTable = void 0;
+const zlib_1 = require("zlib");
+function gzipDecodeFn(b) {
+    try {
+        return (0, zlib_1.gunzipSync)(b);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function brotliDecodeFn(b) {
+    try {
+        return (0, zlib_1.brotliDecompressSync)(b);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function deflateFn(b) {
+    try {
+        return (0, zlib_1.inflateSync)(b);
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.contentDecodingTable = {
+    gzip: gzipDecodeFn,
+    br: brotliDecodeFn,
+    deflate: deflateFn,
+};
+exports.contentEncodingTable = {
+    gzip: (b) => (0, zlib_1.gzipSync)(b),
+    br: (b) => (0, zlib_1.brotliCompressSync)(b),
+    deflate: (b) => (0, zlib_1.deflateSync)(b)
+};

package/dist/http/content/parser.d.ts

@@ -0,0 +1 @@
+export declare const contentParserTable: Record<string, (b: any) => any>;