tezx 3.0.14-beta → 3.0.14-beta2

package/cjs/middleware/secure-headers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureHeaders = void 0;
+const index_js_1 = require("../helper/index.js");
+const joinSrc = (v) => typeof v === "string" ? v : v.join(" ");
+const buildCSPString = (cspObj) => {
+    const parts = [];
+    for (const key in cspObj)
+        parts.push(`${key} ${joinSrc(cspObj[key])}`);
+    return parts.join("; ");
+};
+const secureHeaders = (userOpts = {}) => {
+    const defaultPresets = {
+        strict: {
+            preset: "strict",
+            hsts: { maxAge: 63072000, includeSubDomains: true, preload: true },
+            frameGuard: "DENY",
+            noSniff: true,
+            xssProtection: true,
+            referrerPolicy: "strict-origin-when-cross-origin",
+            permissionsPolicy: "geolocation=(), microphone=(), camera=(), usb=()",
+            csp: {
+                "default-src": ["'self'"],
+                "script-src": ["'self'"],
+                "style-src": ["'self'", "'unsafe-inline'"],
+                "img-src": ["'self'", "data:", "blob:"],
+                "font-src": ["'self'"],
+                "connect-src": ["'self'"],
+                "object-src": ["'none'"],
+                "frame-ancestors": ["'none'"],
+            },
+            cspReportOnly: false,
+        },
+        balanced: {
+            preset: "balanced",
+            hsts: { maxAge: 31536000, includeSubDomains: true, preload: true },
+            frameGuard: "SAMEORIGIN",
+            noSniff: true,
+            xssProtection: true,
+            referrerPolicy: "no-referrer-when-downgrade",
+            permissionsPolicy: "geolocation=(), microphone=()",
+            csp: {
+                "default-src": ["'self'"],
+                "script-src": ["'self'", "https://cdn.jsdelivr.net"],
+                "style-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "https://fonts.googleapis.com",
+                ],
+                "img-src": ["'self'", "data:", "https://images.example.com"],
+                "connect-src": ["'self'", "https://api.example.com"],
+            },
+            cspReportOnly: true,
+        },
+        dev: {
+            preset: "dev",
+            hsts: undefined,
+            frameGuard: "SAMEORIGIN",
+            noSniff: false,
+            xssProtection: false,
+            referrerPolicy: "no-referrer",
+            permissionsPolicy: "",
+            csp: {
+                "default-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "'unsafe-eval'",
+                    "http://localhost:3000",
+                ],
+                "img-src": ["'self'", "data:", "blob:"],
+            },
+            cspReportOnly: true,
+        },
+    };
+    const preset = userOpts.preset ?? "balanced";
+    const base = {
+        ...(defaultPresets[preset] || defaultPresets.balanced),
+        ...userOpts,
+    };
+    const frameHeader = base.frameGuard || "SAMEORIGIN";
+    const xssHeader = base.xssProtection ? "1; mode=block" : "0";
+    const noSniffHeader = base.noSniff ? "nosniff" : "";
+    const permissionsHeader = base.permissionsPolicy || "";
+    const referrerHeader = base.referrerPolicy || "no-referrer";
+    const hstsParts = [`max-age=${base.hsts?.maxAge || 31536000}`];
+    if (base.hsts?.includeSubDomains)
+        hstsParts.push("includeSubDomains");
+    if (base.hsts?.preload)
+        hstsParts.push("preload");
+    const hstsHeader = hstsParts.join("; ");
+    let cspStatic = null;
+    let cspNeedsNonce = !!base.cspUseNonce;
+    if (typeof base.csp === "string")
+        cspStatic = base.csp;
+    else if (base.csp)
+        cspStatic = buildCSPString(base.csp);
+    const cspReportOnly = !!base.cspReportOnly;
+    const ultraFast = !!base.ultraFastMode;
+    if (cspNeedsNonce && ultraFast) {
+        index_js_1.GlobalConfig.debugging.warn("secureHeaders: ultraFastMode disables CSP nonce support. Nonce will not be used.");
+    }
+    if (ultraFast)
+        cspNeedsNonce = false;
+    return async (ctx, next) => {
+        try {
+            if (base.hsts) {
+                const proto = (ctx.req?.header("x-forwarded-proto") || "").toString();
+                if (!base.hsts.hstsOnlyOnHttps || proto.includes("https")) {
+                    ctx.headers.set("Strict-Transport-Security", hstsHeader);
+                }
+            }
+            ctx.headers.set("X-Frame-Options", frameHeader);
+            ctx.headers.set("X-Content-Type-Options", noSniffHeader);
+            ctx.headers.set("X-XSS-Protection", xssHeader);
+            ctx.headers.set("Referrer-Policy", referrerHeader);
+            if (permissionsHeader)
+                ctx.headers.set("Permissions-Policy", permissionsHeader);
+            if (cspNeedsNonce) {
+                const nonce = (0, index_js_1.generateRandomBase64)();
+                let cspHeader = cspStatic;
+                if (!cspHeader) {
+                    cspHeader = `default-src 'self'; script-src 'self' 'nonce-${nonce}'`;
+                }
+                if (typeof base.csp === "object") {
+                    const idx = cspHeader.indexOf("script-src");
+                    if (idx >= 0) {
+                        const parts = [];
+                        parts.push(cspHeader.slice(0, idx + 10));
+                        parts.push(" 'nonce-" + nonce + "'");
+                        parts.push(cspHeader.slice(idx + 10));
+                        cspHeader = parts.join("");
+                    }
+                    else {
+                        cspHeader += "; script-src 'self' 'nonce-" + nonce + "'";
+                    }
+                }
+                ctx.cspNonce = nonce;
+                if (cspReportOnly)
+                    ctx.headers.set("Content-Security-Policy-Report-Only", cspHeader);
+                else
+                    ctx.headers.set("Content-Security-Policy", cspHeader);
+            }
+            else if (cspStatic) {
+                if (cspReportOnly)
+                    ctx.headers.set("Content-Security-Policy-Report-Only", cspStatic);
+                else
+                    ctx.headers.set("Content-Security-Policy", cspStatic);
+            }
+            return await next();
+        }
+        catch (err) {
+            console.error("secureHeaders middleware error", err);
+            return await next();
+        }
+    };
+};
+exports.secureHeaders = secureHeaders;

package/cjs/node/env.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadEnv = loadEnv;
 const node_fs_1 = require("node:fs");
-const runtime_js_1 = require("../utils/runtime.js");
+const error_js_1 = require("../core/error.js");
 const colors_js_1 = require("../utils/colors.js");
+const runtime_js_1 = require("../utils/runtime.js");
 function parseEnvFile(filePath, result) {
     try {
-        if (runtime_js_1.runtime !== "bun" && runtime_js_1.runtime !== "node") {
-            throw new Error(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime_js_1.runtime}"`, "bgRed")} environment`);
+        if (runtime_js_1.runtime !== "node") {
+            throw new error_js_1.TezXError(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime_js_1.runtime}"`, "bgRed")} environment`);
         }
         let fileExists = (0, node_fs_1.existsSync)(filePath);
         if (!fileExists) {

package/cjs/node/serveStatic.js

@@ -5,6 +5,7 @@ exports.getFiles = getFiles;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const low_level_js_1 = require("../utils/low-level.js");
+const error_js_1 = require("../core/error.js");
 function serveStatic(...args) {
     let route = "";
     let dir;
@@ -25,7 +26,7 @@ function serveStatic(...args) {
             [dir] = args;
             break;
         default:
-            throw new Error(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+            throw new error_js_1.TezXError(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
     }
     return {
         files: getFiles(dir, route, options),

package/cjs/node/ws.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upgradeWebSocket = upgradeWebSocket;
+const error_js_1 = require("../core/error.js");
 function upgradeWebSocket(callback, options = {}) {
     const { onUpgradeError = (error, ctx) => {
         ctx.setStatus = 401;
@@ -49,13 +50,13 @@ function upgradeWebSocket(callback, options = {}) {
                 return next();
             }
             ctx.setStatus = 401;
-            return onUpgradeError(new Error("401 Bad Request: Invalid WebSocket headers"), ctx);
+            return onUpgradeError(new error_js_1.TezXError("401 Bad Request: Invalid WebSocket headers", 401), ctx);
         }
         ctx.wsProtocol = ctx.url?.startsWith("https") ? "wss" : "ws";
         const server = ctx.args?.[2];
         if (!server?.on) {
             ctx.setStatus = 500;
-            return onUpgradeError(new Error("Node server instance missing for WebSocket"), ctx);
+            return onUpgradeError(new error_js_1.TezXError("Node server instance missing for WebSocket", 426), ctx);
         }
         const { WebSocketServer } = await Promise.resolve().then(() => __importStar(require("ws")));
         const wss = new WebSocketServer({

package/cjs/registry/RadixRouter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RadixRouter = void 0;
+const error_js_1 = require("../core/error.js");
 const index_js_1 = require("../helper/index.js");
 class RadixRouter {
     root = { children: {} };
@@ -22,7 +23,7 @@ class RadixRouter {
                 }
                 else if (node.children[":"]?.paramName !== paramName ||
                     node.children[":"]?.isOptional !== isOptional) {
-                    throw new Error(`Conflicting param definition for ${paramName}`);
+                    throw new error_js_1.TezXError(`Conflicting param definition for ${paramName}`);
                 }
                 node = node.children[":"];
             }
@@ -145,35 +146,3 @@ class RadixRouter {
     }
 }
 exports.RadixRouter = RadixRouter;
-const routes = [
-    "/",
-    "/users",
-    "/users/:id",
-    "/users/:id/profile",
-    "/posts/:postId?",
-    "/files/*",
-    "/admin/settings",
-    "/search/:term?",
-    "/categories/:categoryId/products/:productId",
-    "/about",
-];
-const testPaths = [
-    "/",
-    "/users",
-    "/users/123",
-    "/users/123/profile",
-    "/posts",
-    "/posts/456",
-    "/files/path/to/file.txt",
-    "/admin/settings",
-    "/search",
-    "/search/nodejs",
-    "/categories/12/products/999",
-    "/notfound",
-];
-const router = new RadixRouter();
-let x = function xx() {
-    return {
-        body: "3453455",
-    };
-};

package/cjs/utils/buffer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Decode = base64Decode;
+function base64Decode(base64) {
+    const pad = base64.length % 4;
+    if (pad)
+        base64 += "=".repeat(4 - pad);
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(base64, "base64").toString("utf-8");
+    }
+    else if (typeof atob === "function") {
+        return new TextDecoder().decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
+    }
+    else {
+        throw new Error("Base64 decode not supported in this environment");
+    }
+}

package/cjs/utils/file.js

@@ -37,6 +37,8 @@ exports.fileExists = fileExists;
 exports.getFileBuffer = getFileBuffer;
 exports.readStream = readStream;
 exports.fileSize = fileSize;
+exports.etagDigest = etagDigest;
+const error_js_1 = require("../core/error.js");
 const runtime_js_1 = require("./runtime.js");
 async function fileExists(path) {
     switch (runtime_js_1.runtime) {
@@ -76,7 +78,7 @@ async function getFileBuffer(path) {
         case "deno":
             return Deno.readFile(path);
         default:
-            throw new Error("Unsupported runtime environment");
+            throw new error_js_1.TezXError("Unsupported runtime environment");
     }
 }
 async function readStream(path) {
@@ -93,22 +95,42 @@ async function readStream(path) {
             return (await Deno.open(path, { read: true })).readable;
         }
         default:
-            throw new Error("Unsupported runtime environment");
+            throw new error_js_1.TezXError("Unsupported runtime environment");
     }
 }
 async function fileSize(path) {
     switch (runtime_js_1.runtime) {
         case "node": {
             const { stat } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
-            return (await stat(path)).size;
+            const st = await stat(path);
+            return { size: st.size, mtime: st.mtime };
         }
         case "bun": {
-            return Bun.file(path).size;
+            const st = await Bun.file(path).stat();
+            return { size: st.size, mtime: st.mtime };
         }
         case "deno": {
-            return (await Deno.stat(path)).size;
+            const st = await Deno.stat(path);
+            return {
+                size: st.size,
+                mtime: st.mtime ?? new Date(),
+            };
         }
         default:
-            return 0;
+            throw new error_js_1.TezXError("Unsupported runtime: " + runtime_js_1.runtime);
     }
 }
+async function etagDigest(algo = "MD5", data) {
+    const encoded = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (runtime_js_1.runtime === "bun") {
+        return Bun.hash(data, 256).toString(16);
+    }
+    if (globalThis?.crypto?.subtle) {
+        const buffer = await crypto.subtle.digest(algo, encoded);
+        return Array.from(new Uint8Array(buffer))
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    const { createHash } = await Promise.resolve().then(() => __importStar(require("node:crypto")));
+    return createHash(algo).update(encoded).digest("hex");
+}

package/cjs/utils/generateID.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateID = generateID;
 exports.generateUUID = generateUUID;
+exports.generateRandomBase64 = generateRandomBase64;
 function generateID() {
     const timestamp = Date.now().toString(16);
     let randomHex = "";
@@ -25,3 +26,12 @@ function generateUUID() {
         return crypto.randomUUID();
     return generateID();
 }
+function generateRandomBase64(length = 16) {
+    let result = "";
+    const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (let i = 0; i < length; i++) {
+        const idx = Math.floor(Math.random() * 64);
+        result += BASE64[idx];
+    }
+    return result;
+}

package/cjs/utils/response.js

@@ -16,7 +16,9 @@ exports.notFoundResponse = notFoundResponse;
 async function handleErrorResponse(err = error_js_1.TezXError.internal(), ctx) {
     if (err instanceof error_js_1.TezXError) {
         config_js_1.GlobalConfig.debugging.error(err.details ?? err?.message);
-        return ctx.status(err.statusCode ?? 500).send(err.details ?? err?.message ?? "Internal Server Error");
+        return ctx
+            .status(err.statusCode ?? 500)
+            .send(err.details ?? err?.message ?? "Internal Server Error");
     }
     return await handleErrorResponse(error_js_1.TezXError.internal(), ctx);
 }

package/core/context.d.ts

@@ -252,9 +252,9 @@ export declare class Context<TEnv extends Record<string, any> = {}, TPath extend
         filename?: string;
     }): Promise<HttpBaseResponse>;
     /**
-     * bun [server]
-     * deno [connInfo]
-     * node [res, server]
+     *@property bun [server]
+     *@property deno [connInfo]
+     *@property node [res, server]
      */
     protected get args(): any;
 }

package/core/context.js

@@ -2,6 +2,7 @@ import { fileExists, fileSize, getFileBuffer, readStream, } from "../utils/file.
 import { extensionExtract } from "../utils/low-level.js";
 import { defaultMimeType, mimeTypes } from "../utils/mimeTypes.js";
 import { determineContentTypeBody, toString } from "../utils/response.js";
+import { TezXError } from "./error.js";
 import { TezXRequest } from "./request.js";
 export class Context {
     #status = 200;
@@ -133,7 +134,7 @@ export class Context {
     }
     async download(filePath, filename) {
         if (!(await fileExists(filePath)))
-            throw Error("File not found");
+            throw TezXError.notFound("File not found");
         const buf = await getFileBuffer(filePath);
         const headers = {
             "Content-Disposition": `attachment; filename="${filename}"`,
@@ -146,8 +147,8 @@ export class Context {
     }
     async sendFile(filePath, init) {
         if (!(await fileExists(filePath)))
-            throw Error("File not found");
-        let size = await fileSize(filePath);
+            throw TezXError.notFound("File not found");
+        let { size, mtime } = await fileSize(filePath);
         const ext = extensionExtract(filePath);
         const mimeType = mimeTypes[ext] ?? defaultMimeType;
         let fileStream = await readStream(filePath);

package/core/error.d.ts

@@ -93,3 +93,4 @@ export declare class TezXError extends Error {
         details: any;
     };
 }
+export declare function TezXErrorParse(err: unknown, statusCode?: number): TezXError;

package/core/error.js

@@ -35,3 +35,10 @@ export class TezXError extends Error {
         };
     }
 }
+export function TezXErrorParse(err, statusCode) {
+    if (err instanceof TezXError)
+        return err;
+    else if (err instanceof Error)
+        return new TezXError(err?.message, 500, err?.stack);
+    return new TezXError(String(err), statusCode);
+}

package/core/request.js

@@ -1,4 +1,5 @@
 import { url2query } from "../utils/url.js";
+import { TezXError } from "./error.js";
 export class TezXRequest {
     url;
     method;
@@ -80,11 +81,11 @@ export class TezXRequest {
             return this.#cachedFormObject;
         const ct = this.#contentType;
         if (!ct)
-            throw new Error("Missing Content-Type");
+            throw new TezXError("Missing Content-Type");
         if (ct === "application/x-www-form-urlencoded" ||
             ct === "multipart/form-data") {
             if (this.#bodyConsumed) {
-                throw new Error("Multipart body already consumed elsewhere");
+                throw new TezXError("Multipart body already consumed elsewhere");
             }
             this.#cachedFormObject = (await this.#rawRequest.formData());
             this.#bodyConsumed = true;

package/core/router.d.ts

@@ -3,11 +3,6 @@ import { Callback, HandlerType, HTTPMethod, Middleware, RouteRegistry, ServeStat
  * Router configuration options.
  */
 export type RouterConfig = {
-    /**
-     * Custom route registry instance used internally to store routes.
-     * If not provided, the router will use the default CombineRouteRegistry.
-     */
-    routeRegistry?: RouteRegistry;
     /**
      * `env` allows you to define environment variables for the router instance.
      * Example: `{ NODE_ENV: "production", API_VERSION: 2 }`
@@ -33,7 +28,7 @@ export declare class Router<T extends Record<string, any> = {}> {
     /** Environment variables accessible within this router */
     protected env: Record<string, string | number>;
     /** Internal route registry to hold all routes */
-    protected router: RouteRegistry;
+    protected router?: RouteRegistry;
     /** Array tracking registered routes and their handlers */
     protected route: {
         method: string;
@@ -52,7 +47,7 @@ export declare class Router<T extends Record<string, any> = {}> {
      * @param config.env - Environment variables for router
      * @param config.routeRegistry - Custom route registry instance
      */
-    constructor({ basePath, env, routeRegistry, }?: RouterConfig);
+    constructor({ basePath, env }?: RouterConfig);
     /**
      * Registers static file routes to the application for serving files like HTML, CSS, JS, images, etc.
      *
@@ -61,7 +56,7 @@ export declare class Router<T extends Record<string, any> = {}> {
      *
      * @example
      * ```ts
-     * import { serveStatic } from "tezx/bun"; // or "tezx/node" or "tezx/deno"
+     * import { serveStatic } from "tezx/bun"; // or "tezx/node"
      *
      * app.static(
      *   serveStatic("public", {

package/core/router.js

@@ -1,13 +1,12 @@
-import { RadixRouter } from "../registry/RadixRouter.js";
 import { sanitizePathSplitBasePath } from "../utils/low-level.js";
+import { TezXError } from "./error.js";
 export class Router {
     env = {};
     router;
     route = [];
     staticFile = Object.create(null);
     basePath;
-    constructor({ basePath = "/", env = {}, routeRegistry = new RadixRouter(), } = {}) {
-        this.router = routeRegistry;
+    constructor({ basePath = "/", env = {} } = {}) {
         this.basePath = basePath;
         this.env = { ...env };
         this.get = this.get.bind(this);
@@ -29,7 +28,7 @@ export class Router {
                     if (headers) {
                         for (const key in headers) {
                             let value = headers?.[key];
-                            ctx.setHeader(key, value);
+                            ctx.headers.set(key, value);
                         }
                     }
                     return ctx.sendFile(r.fileSource);
@@ -74,14 +73,14 @@ export class Router {
         return this;
     }
     addRouter(path, router) {
-        return this.#routeAddTriNode(path, router);
+        return this.#addRouterInstance(path, router);
     }
     group(prefix, callback) {
         const router = new Router({
             basePath: prefix,
         });
         callback(router);
-        this.#routeAddTriNode("/", router);
+        this.#addRouterInstance("/", router);
         return this;
     }
     use(...args) {
@@ -128,7 +127,7 @@ export class Router {
     }
     #addRoute(method, path, handlers) {
         let pattern = `/${sanitizePathSplitBasePath(this.basePath, path).join("/")}`;
-        this.router.addRoute(method, pattern, handlers);
+        this.router?.addRoute(method, pattern, handlers);
         this.route.push({
             method: method,
             pattern: pattern,
@@ -137,7 +136,7 @@ export class Router {
     }
     #registerRoute(method, path, ...args) {
         if (args.length === 0) {
-            throw new Error("At least one handler is required.");
+            throw new TezXError("At least one handler is required.");
         }
         let middlewares = [];
         let callback;
@@ -154,22 +153,17 @@ export class Router {
             callback = args[0];
         }
         if (typeof callback !== "function") {
-            throw new Error("Route callback function is missing or invalid.");
+            throw new TezXError("Route callback function is missing or invalid.");
         }
         if (!middlewares.every((middleware) => typeof middleware === "function")) {
-            throw new Error("Middleware must be a function or an array of functions.");
+            throw new TezXError("Middleware must be a function or an array of functions.");
         }
         this.#addRoute(method, path, [...middlewares, callback]);
     }
-    #routeAddTriNode(path, router) {
+    #addRouterInstance(path, router) {
         this.env = { ...this.env, ...router.env };
-        if (this.router?.name &&
-            router.router?.name &&
-            this.router?.name !== router.router?.name) {
-            throw new Error(`Router name mismatch: expected "${this.router.name}", got "${router.router.name}"`);
-        }
         if (!(router instanceof Router)) {
-            throw new Error("Router instance is required.");
+            throw new TezXError("Router instance is required.");
         }
         router.route.forEach((r) => {
             this.#addRoute(r?.method, `/${sanitizePathSplitBasePath(path, r?.pattern).join("/")}`, r?.handlers);

package/core/server.d.ts

@@ -1,4 +1,4 @@
-import { Callback, ErrorHandler } from "../types/index.js";
+import { Callback, ErrorHandler, RouteRegistry } from "../types/index.js";
 import { Router, RouterConfig } from "./router.js";
 export type TezXConfig = {
     /**
@@ -20,6 +20,11 @@ export type TezXConfig = {
      * @returns The transformed or resolved path used for routing (e.g., `/api/users`)
      */
     onPathResolve?: (pathname: string) => string;
+    /**
+     * Custom route registry instance used internally to store routes.
+     * If not provided, the router will use the default CombineRouteRegistry.
+     */
+    routeRegistry?: RouteRegistry;
     /**
      * Enables or disables debugging for the middleware.
      * When set to `true`, detailed debug logs will be output,
@@ -31,7 +36,7 @@ export type TezXConfig = {
 } & RouterConfig;
 /**
  * TezX is an ultra-fast, flexible request router and server handler.
- * It supports plug-and-play for Deno, Bun, and Node runtimes.
+ * It supports plug-and-play for Bun, and Node runtimes.
  *
  * @template T - The environment object shared across requests.
  *
@@ -45,6 +50,8 @@ export type TezXConfig = {
  */
 export declare class TezX<T extends Record<string, any> = {}> extends Router<T> {
     #private;
+    /** Internal route registry to hold all routes */
+    protected router?: RouteRegistry;
     constructor({ basePath, env, debugMode, onPathResolve, routeRegistry, }?: TezXConfig);
     /**
      * Register a custom 404 (not found) handler.
@@ -85,27 +92,7 @@ export declare class TezX<T extends Record<string, any> = {}> extends Router<T>
      *   port: 3001,
      *   reusePort: true, // enables SO_REUSEPORT for clustering
      *   fetch: app.serve,
-     *   websocket: {
-     *     open(ws) {
-     *       console.log(ws.data);
-     *       return ws.data?.open?.(ws);
-     *     },
-     *     message(ws, msg) {
-     *       return ws.data?.message?.(ws, msg);
-     *     },
-     *     close(ws, code, reason) {
-     *       return ws.data?.close?.(ws, { code, reason });
-     *     },
-     *     ping(ws, data) {
-     *       return ws.data?.ping?.(ws, data);
-     *     },
-     *     pong(ws, data) {
-     *       return ws.data?.pong?.(ws, data);
-     *     },
-     *     drain(ws) {
-     *       return ws.data?.drain?.(ws);
-     *     },
-     *   },
+     *   websocket: wsHandlers()
      * });
      * ```
      *