corecdtl 0.1.0

package/dist/http/context/WebContext.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    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 __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 });
+const parser_1 = require("../content/parser");
+const encoding_1 = require("../content/encoding");
+const http_1 = require("../../http");
+const HttpContext_1 = __importDefault(require("./HttpContext"));
+const Factory = __importStar(require("../factory/factory"));
+const net_1 = __importDefault(require("net"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const hypernode_1 = require("../../hypernode");
+function isFingerprinted(name) {
+    return /\.[a-f0-9]{8,}\./i.test(name);
+}
+const MIME_MAP = {
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".css": "text/css",
+    ".html": "text/html",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2"
+};
+class WebContext extends HttpContext_1.default {
+    constructor(ctxOpts, opts) {
+        super(opts);
+        this.contentDecoding = encoding_1.contentDecodingTable;
+        this.contentEncoding = encoding_1.contentEncodingTable;
+        this.contentTypeParsers = parser_1.contentParserTable;
+        this.parseInitial = (socket, chunk, p) => {
+            const routeId = this.httpCore.scannerRouteFirst(chunk, p, this.state.maxHeaderNameSize, this.state.maxHeaderValueSize, this.state.maxContentSize, this.state.requestQuerySize);
+            if (p.retFlag !== http_1.Http.RetFlagBits.FLAG_OK) {
+                switch (p.retFlag) {
+                    // --- CORS 204 ---
+                    case http_1.Http.RetFlagBits.FLAG_CORS_PREFLIGHT:
+                        socket.write(Buffer.from("HTTP/1.1 204 No Content\r\n" +
+                            this.state.corsHeaders + "\r\n" +
+                            "Content-Length: 0\r\n\r\n"));
+                        socket.destroy();
+                        return;
+                    // --- VERSION UNSUPPORTED ---
+                    case http_1.Http.RetFlagBits.FLAG_HTTP_VERSION_UNSUPPORTED:
+                        socket.write(this.errorRespMap.RESP_505);
+                        socket.destroy();
+                        return;
+                    // --- METHOD NOT ALLOWED ---
+                    case http_1.Http.RetFlagBits.FLAG_METHOD_NOT_ALLOWED:
+                        socket.write(this.errorRespMap.RESP_405);
+                        socket.destroy();
+                        return;
+                    // --- REQUEST QUERY EXCEEDED ---
+                    case http_1.Http.RetFlagBits.FLAG_REQUEST_QUERY_EXCEEDED:
+                        socket.write(this.errorRespMap.RESP_414);
+                        socket.destroySoon();
+                        return;
+                    // --- NOT FOUND ---
+                    case http_1.Http.RetFlagBits.FLAG_NOT_FOUND:
+                        if (this.enableCors) {
+                            socket.write(this.errorRespMap.RESP_204);
+                        }
+                        else {
+                            socket.write(this.errorRespMap.RESP_404);
+                        }
+                        socket.destroy();
+                        return;
+                    // === HEADER ERRORS ===
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_ARGUMENT:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_HEADER:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_CONTENT_LENGTH:
+                    case http_1.Http.RetFlagBits.FLAG_CONTENT_LENGTH_EXCEEDED:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_NAME_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_VALUE_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_DUPLICATE_SINGLE_HEADER:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroy();
+                        return;
+                    case http_1.Http.RetFlagBits.FLAG_UNTERMINATED_HEADERS:
+                        p.rawBuf = chunk;
+                        p.routePipe = this.routePipes[routeId];
+                        p.fn = this.parseHeader;
+                        return;
+                    // --- OTHER (fallback) ---
+                    default:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroy();
+                        return;
+                }
+            }
+            this.routeDefinationFns[routeId](socket, p, routeId, chunk);
+        };
+        this.publicRouteDefinationFn = (socket, p, routeId, chunk) => {
+            const assetPath = this.assetParser.handlePublicAsset(chunk, 4 + 1 // GET(3) 1 is SPACE and Last 1 is => /
+            );
+            let entry = this.assetCache.get(assetPath);
+            if (!entry) {
+                entry = this.loadAsset(assetPath);
+                if (!entry) {
+                    socket.write("HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n");
+                    p.free();
+                    socket.end();
+                    return;
+                }
+                this.assetCache.set(assetPath, entry);
+            }
+            socket.write(entry.payload);
+            p.reset();
+            socket.end();
+        };
+        this.spaRouteDefinationFn = (socket, p, routeId, _) => {
+            p.free();
+            socket.write(this.spaRespBuffer);
+            socket.end();
+        };
+        this.dynamicRouteDefinationFn = (socket, p, routeId, chunk) => {
+            p.rawBuf = chunk;
+            const h = p.headers;
+            const hostHeader = h.host;
+            if (!hostHeader) {
+                socket.write(this.errorRespMap.RESP_400);
+                socket.destroy();
+                return;
+            }
+            p.routePipe = this.routePipes[routeId];
+            p.routePipe.accumulateHandler(socket, p);
+        };
+        this.parseHeader = (socket, chunk, p) => {
+            p.rawBuf = Buffer.concat([p.rawBuf, chunk]);
+            this.httpCore.scannerHeader(p.rawBuf, p, this.state.maxHeaderNameSize, this.state.maxHeaderValueSize, this.state.maxContentSize);
+            if (p.retFlag !== http_1.Http.RetFlagBits.FLAG_OK) {
+                switch (p.retFlag) {
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_ARGUMENT:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_HEADER:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_CONTENT_LENGTH:
+                    case http_1.Http.RetFlagBits.FLAG_CONTENT_LENGTH_EXCEEDED:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_NAME_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_VALUE_SIZE:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroySoon();
+                        return;
+                    case http_1.Http.RetFlagBits.FLAG_UNTERMINATED_HEADERS:
+                        return;
+                }
+            }
+            this.routeDefinationFns[p.routePipe.routeId](socket, p, p.routePipe.routeId, chunk);
+        };
+        this.publicRoutePathName = ctxOpts?.publicStaticPath == undefined ? "dist" : ctxOpts.publicStaticPath;
+        this.publicStaticRoute = ctxOpts?.publicStaticRoute == undefined ? "/public" : ctxOpts.publicStaticRoute;
+        this.assetParser = new hypernode_1.hypernode.PublicAssetParser();
+        this.assetParser.setAssetRoute(this.publicStaticRoute);
+        this.spaRootPath = ctxOpts?.spaRootPath == undefined ? "dist/index.html" : ctxOpts.spaRootPath;
+        const _data = fs_1.default.readFileSync(this.spaRootPath);
+        const __resp = Buffer.from("HTTP/1.1 200 OK\r\n" +
+            "Content-Type: text/html; charset=utf-8\r\n" +
+            "Content-Length: " + _data.length + "\r\n" +
+            "Cache-Control: no-cache\r\n" +
+            "\r\n", "ascii");
+        this.assetCache = new Map();
+        this.setAllAssets();
+        this.spaRespBuffer = Buffer.concat([__resp, _data]);
+        this.initRuntime();
+        this.bindServer(opts?.netServerOptions);
+    }
+    bindServer(netServerOptions) {
+        this.server = new net_1.default.Server(netServerOptions, (socket) => {
+            let p = this.chunkPool.allocate();
+            if (!p) {
+                socket.destroy();
+                return;
+            }
+            socket.setTimeout(this.state.timeout);
+            // socket.setNoDelay(true);
+            socket.on("data", chunk => {
+                p.fn(socket, chunk, p);
+            });
+            socket.on("timeout", () => {
+                socket.destroy();
+            });
+            socket.on("error", (err) => {
+                socket.destroy();
+            });
+            socket.on("close", () => {
+                p.free();
+            });
+        });
+    }
+    registerRouters(mainRoute) {
+        let _startRoutePath = "/";
+        if (mainRoute == undefined) {
+            mainRoute = Factory.createRoute(_startRoutePath);
+        }
+        else {
+            _startRoutePath = mainRoute.url;
+            /* Same time add dynamic EPs */
+        }
+        const __routePublic = this.makeRoutePublic();
+        const _routeSPA = this.makeRouteSPA();
+        mainRoute.addRoute(__routePublic);
+        mainRoute.addRoute(_routeSPA);
+        super.registerRouters(mainRoute);
+        this.setRouteDefinationFn(_startRoutePath);
+    }
+    makeRouteSPA() {
+        const spaRoute = Factory.createRoute("*");
+        spaRoute.addEndpoint(Factory.createEndpoint(http_1.Http.HttpMethod.GET, "", null));
+        return spaRoute;
+    }
+    makeRoutePublic() {
+        const _route = Factory.createRoute(this.publicStaticRoute);
+        const _ep = Factory.createEndpoint(http_1.Http.HttpMethod.GET, "/*", null);
+        _route.addEndpoint(_ep);
+        return _route;
+    }
+    setRouteDefinationFn(_startRoute) {
+        const _routeDefinationFns = Array(this.routePipes.length);
+        for (let i = 0; i < this.routePipes.length; i++) {
+            const e = this.routePipes[i];
+            if (e.url == _startRoute.concat("*")) {
+                _routeDefinationFns[i] = this.spaRouteDefinationFn;
+            }
+            else if (e.url == _startRoute.concat(this.publicStaticRoute).concat("/*")) {
+                _routeDefinationFns[i] = this.publicRouteDefinationFn;
+            }
+            else {
+                _routeDefinationFns[i] = this.dynamicRouteDefinationFn;
+            }
+        }
+        this.routeDefinationFns = _routeDefinationFns;
+    }
+    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;
+                }
+                if (!entry.isFile())
+                    continue;
+                const asset = this.loadAsset(urlPath);
+                if (!asset)
+                    continue;
+                this.assetCache.set(urlPath, asset);
+            }
+        };
+        walk(this.publicRoutePathName, "");
+    }
+    loadAsset(assetPath) {
+        try {
+            const 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();
+            const mime = MIME_MAP[ext] ?? "application/octet-stream";
+            const immutable = isFingerprinted(assetPath);
+            const cacheControl = immutable
+                ? "public, max-age=31536000, immutable"
+                : "public, max-age=0, must-revalidate";
+            const headers = Buffer.from("HTTP/1.1 200 OK\r\n" +
+                `Content-Type: ${mime}\r\n` +
+                `Content-Length: ${size}\r\n` +
+                `Cache-Control: ${cacheControl}\r\n` +
+                "\r\n");
+            const payload = Buffer.concat([headers, body]);
+            return { headers, body, size, payload };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    setHttpCore() {
+        super.setHttpCore("web");
+    }
+}
+exports.default = WebContext;

package/dist/http/factory/accumulator.d.ts

@@ -0,0 +1,13 @@
+import { Http } from "../../http";
+import net from "net";
+export declare function createAccumulators(ctx: {
+    contentTypeParsers: Http.ContentTypeParser;
+    contentDecoding: Http.ContentDecoding;
+    errorRespMap: Http.HttpStaticResponseMap;
+}): {
+    accumulatorHeadGet: (socket: net.Socket, p: Http.ChunkProgression) => void;
+    decisionAccumulate: (socket: net.Socket, p: Http.ChunkProgression) => void;
+    accumulatorDefinedType: (socket: net.Socket, p: Http.ChunkProgression) => Promise<void>;
+    accumulatorDefinedEncode: (socket: net.Socket, p: Http.ChunkProgression) => Promise<void>;
+    accumulatorDefinedTypeEncode: (socket: net.Socket, p: Http.ChunkProgression) => Promise<void>;
+};

package/dist/http/factory/accumulator.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccumulators = createAccumulators;
+function createAccumulators(ctx) {
+    const { contentTypeParsers, contentDecoding, errorRespMap } = ctx;
+    function accumulatorHeadGet(socket, p) {
+        socket.pause();
+        p.routePipe.pipeHandler(p, p.routePipe.mws, (ret) => {
+            socket.write(ret);
+            const con = p.headers.connection;
+            if (con == "close")
+                socket.destroySoon();
+            else {
+                p.reset();
+                socket.resume();
+            }
+        });
+    }
+    // ==============================
+    // UNTIL-END MODE
+    // ==============================
+    function accumulateUntilEnd(socket, chunk, p) {
+        if (p.rawBuf.length + chunk.length > p.routePipe.maxContentSize) {
+            socket.write(errorRespMap.RESP_413);
+            socket.destroy();
+            return;
+        }
+        p.chunkParser.untilEnd.write(chunk);
+    }
+    // ==============================
+    // FIXED LENGTH MODE
+    // ==============================
+    async function accumulateDef(socket, chunk, p) {
+        const acc = p.chunkParser.fixed;
+        const progress = acc.getTotalWrittenSize() + chunk.length;
+        if (progress > p.contentLen) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroy();
+            return;
+        }
+        if (progress > p.routePipe.maxContentSize) {
+            socket.write(errorRespMap.RESP_413);
+            socket.destroy();
+            return;
+        }
+        acc.write(chunk);
+        // BODY DONE
+        if (progress === p.contentLen) {
+            socket.pause();
+            const b = acc.getBody();
+            acc.free();
+            const ret = await p.routePipe.pipeHandler(b, p, contentTypeParsers, contentDecoding, p.routePipe.mws, (ret) => {
+                socket.write(ret);
+                const con = p.headers.Connection;
+                if (con == "close")
+                    socket.destroySoon();
+                else {
+                    p.reset();
+                    socket.resume();
+                }
+            });
+        }
+    }
+    // ==============================
+    // CHUNKED MODE (Sync handler, async final processing)
+    // ==============================
+    function accumulateChunked(socket, chunk, p) {
+        const total = p.chunkParser.streaming.getTotalSize();
+        // @ts-ignore
+        if (total + chunk.length > p.routePipe.maxContentSize) {
+            socket.write(errorRespMap.RESP_400);
+            socket.end();
+            return;
+        }
+        p.chunkParser.streaming.write(chunk);
+        if (!p.chunkParser.streaming.isFinished()) {
+            return;
+        }
+        socket.pause();
+        const b = p.chunkParser.streaming.getBody();
+        p.chunkParser.streaming.free();
+        p.routePipe.pipeHandler(b, p, contentTypeParsers, contentDecoding, p.routePipe.mws, (ret) => {
+            socket.write(ret);
+            const con = p.headers.connection;
+            if (con == "close")
+                socket.destroySoon();
+            else {
+                p.reset();
+                socket.resume();
+            }
+        });
+    }
+    // ==============================
+    // DESICION ACCUMULATE AFTER HEADERS
+    // ==============================
+    function decisionAccumulate(socket, p) {
+        const h = p.headers;
+        const transferEnc = h["transfer-encoding"];
+        const contentLenStr = h["content-length"];
+        // ───────────────────────────────────────────────
+        // 1) CHUNKED MODE (Transfer-Encoding: chunked)
+        // ───────────────────────────────────────────────
+        if (transferEnc === "chunked") {
+            const already = p.rawBuf.slice(p.mainOffset);
+            p.fn = accumulateChunked;
+            // İlk chunk'ı senkron olarak işle
+            accumulateChunked(socket, already, p);
+            return;
+        }
+        // ───────────────────────────────────────────────
+        // 2) UNTIL_END MODE (no content-length)
+        // ───────────────────────────────────────────────
+        if (!contentLenStr) {
+            if (!p.routePipe.untilEnd) {
+                socket.write(errorRespMap.RESP_400);
+                socket.destroySoon();
+                return;
+            }
+            socket.on("end", () => {
+                const b = p.chunkParser.untilEnd.getBody();
+                p.routePipe.pipeHandler(b, p, contentTypeParsers, contentDecoding, p.routePipe.mws, () => {
+                    p.chunkParser.untilEnd.free();
+                    socket.destroy();
+                    return;
+                });
+            });
+            p.fn = accumulateUntilEnd;
+            return;
+        }
+        // ───────────────────────────────────────────────
+        // 3) FIXED MODE (content-length N)
+        // ───────────────────────────────────────────────
+        p.contentLen = parseInt(contentLenStr);
+        // Empty body
+        if (p.contentLen === 0) {
+            socket.pause();
+            p.routePipe.pipeHandler(null, p, contentTypeParsers, contentDecoding, p.routePipe.mws, (ret) => {
+                socket.write(ret);
+                const con = h.connection;
+                if (con == "close")
+                    socket.destroySoon();
+                else {
+                    p.reset();
+                    socket.resume();
+                }
+            });
+            return;
+        }
+        const already = p.rawBuf.slice(p.mainOffset);
+        // ───────────────────────────────────────────────
+        // exact match (body fully arrived)
+        // ───────────────────────────────────────────────
+        if (already.length === p.contentLen) {
+            // socket.pause();
+            p.routePipe.pipeHandler(already, p, contentTypeParsers, contentDecoding, p.routePipe.mws, (ret) => {
+                socket.write(ret);
+                if (h.connection == "close") {
+                    socket.destroySoon();
+                }
+                else {
+                    p.reset();
+                    socket.resume();
+                }
+            });
+            return;
+        }
+        // ───────────────────────────────────────────────
+        // overflow attempt → reject immediately
+        // ───────────────────────────────────────────────
+        if (already.length > p.contentLen) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroySoon();
+            return;
+        }
+        // ───────────────────────────────────────────────
+        // incomplete → use FIXED accumulator
+        // ───────────────────────────────────────────────
+        p.chunkParser.fixed.allocateBuffer(p.contentLen);
+        p.chunkParser.fixed.write(already);
+        p.fn = accumulateDef;
+    }
+    async function accumulatorDefinedType(socket, p) {
+        const h = p.headers;
+        if (p.routePipe.ct.type !== h["content-type"]) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroy();
+            return;
+        }
+        await decisionAccumulate(socket, p);
+    }
+    async function accumulatorDefinedEncode(socket, p) {
+        const h = p.headers;
+        if (p.routePipe.ct.encoding !== h["content-encoding"]) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroy();
+            return;
+        }
+        await decisionAccumulate(socket, p);
+    }
+    async function accumulatorDefinedTypeEncode(socket, p) {
+        const h = p.headers;
+        if (p.routePipe.ct.type !== h["content-type"]) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroy();
+            return;
+        }
+        if (p.routePipe.ct.encoding !== h["content-encoding"]) {
+            socket.write(errorRespMap.RESP_400);
+            socket.destroy();
+            return;
+        }
+        await decisionAccumulate(socket, p);
+    }
+    return {
+        accumulatorHeadGet,
+        decisionAccumulate,
+        accumulatorDefinedType,
+        accumulatorDefinedEncode,
+        accumulatorDefinedTypeEncode
+    };
+}

package/dist/http/factory/factory.d.ts

@@ -0,0 +1,5 @@
+import { Http } from "../../http";
+declare function createRoute(url: string): Http.Route;
+declare function createMiddleware(handle: Http.MiddlewareHandleFn | any): Http.Middleware;
+declare function createEndpoint(method: Http.HttpMethod, url: string, handle: Http.EndpointHandleFn | null, ct?: Http.ContentConfig, cfg?: Http.EndpointOpt, accumulateHandle?: Http.AccumulateHandleFn): Http.Endpoint;
+export { createRoute, createMiddleware, createEndpoint, };

package/dist/http/factory/factory.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoute = createRoute;
+exports.createMiddleware = createMiddleware;
+exports.createEndpoint = createEndpoint;
+function validateRouteUrl(url) {
+    if (url.includes("//")) {
+        throw new Error(`Route URL contains '//' double-slash: ${url}`);
+    }
+    // Split and remove empty segments to avoid false positives
+    const segments = url.split("/").filter(Boolean);
+    const nameRegex = /^[a-zA-Z0-9_]+$/;
+    for (const seg of segments) {
+        // Parameter segment ":id"
+        if (seg.startsWith(":")) {
+            const name = seg.slice(1);
+            if (!name)
+                throw new Error(`Empty parameter name ':' in route: ${url}`);
+            if (!nameRegex.test(name))
+                throw new Error(`Invalid parameter name '${name}' in route: ${url}`);
+            continue;
+        }
+        // Wildcard segment "*rest"
+        if (seg.startsWith("*")) {
+            const name = seg.slice(1);
+            // "*" is VALID → unnamed wildcard
+            if (name && !nameRegex.test(name)) {
+                throw new Error(`Invalid wildcard name '${name}' in route: ${url}`);
+            }
+            continue;
+        }
+        // Regular segments have no special constraints for now
+    }
+    return true;
+}
+function normalizeRouteUrl(url) {
+    if (typeof url !== "string")
+        url = String(url);
+    // Convert Windows-style slashes
+    url = url.replace(/\\/g, "/");
+    // Collapse duplicate slashes (but do not force a leading slash)
+    url = url.replace(/\/{2,}/g, "/");
+    // If the whole route is just "/", return as-is
+    if (url === "/")
+        return "/";
+    // Remove trailing slash
+    if (url.endsWith("/")) {
+        url = url.slice(0, -1);
+    }
+    return url;
+}
+function createRoute(url) {
+    url = normalizeRouteUrl(url);
+    validateRouteUrl(url);
+    return {
+        routes: [],
+        endpoints: [],
+        middlewares: [],
+        url,
+        addRoute(r) {
+            this.routes.push(r);
+            return this;
+        },
+        addMiddleware(mw) {
+            this.middlewares.push(mw);
+            return this;
+        },
+        addEndpoint(ep) {
+            this.endpoints.push(ep);
+            return this;
+        }
+    };
+}
+function createMiddleware(handle) {
+    return {
+        handle
+    };
+}
+function createEndpoint(method, url, handle, ct, cfg, accumulateHandle) {
+    url = normalizeRouteUrl(url);
+    validateRouteUrl(url);
+    return {
+        middlewares: [],
+        url,
+        method,
+        handle,
+        ct,
+        maxContentSize: cfg?.maxContentSize,
+        maxHeaderSize: cfg?.maxHeaderSize,
+        untilEnd: cfg?.untilEnd,
+        accumulateHandle,
+        addMiddleware(mw) {
+            this.middlewares.push(mw);
+            return this;
+        },
+    };
+}

package/dist/http/factory/pipeline.d.ts

@@ -0,0 +1,3 @@
+import { Http } from "../../http";
+declare function createPipeline(ep: Http.Endpoint, pipeFns: Http.MiddlewareHandleFn[]): any;
+export { createPipeline };