qhttpx 1.8.5 → 1.8.11

package/dist/src/core/server.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QHTTPX = void 0;
+exports.QHTTPX = exports.QHTTPXContextImpl = void 0;
 const http_1 = __importDefault(require("http"));
 const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
+const querystring_1 = require("querystring");
 const package_json_1 = __importDefault(require("../../package.json"));
 const router_1 = require("../router/router");
 const scheduler_1 = require("./scheduler");
@@ -25,6 +26,165 @@ const types_1 = require("./types");
 const cookies_1 = require("../utils/cookies");
 const scope_1 = require("./scope");
 const logger_1 = require("./logger");
+const EMPTY_QUERY = Object.freeze({});
+class QHTTPXContextImpl {
+    constructor(app) {
+        this._url = null;
+        this._app = app;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._appJsonSerializer = app.options.jsonSerializer;
+        this.json = this.json.bind(this);
+        this.send = this.send.bind(this);
+        this.html = this.html.bind(this);
+        this.redirect = this.redirect.bind(this);
+        this.setCookie = this.setCookie.bind(this);
+        this.render = this.render.bind(this);
+        this.validate = this.validate.bind(this);
+    }
+    get bufferPool() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this._app.bufferPool;
+    }
+    get db() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this._app.options.database;
+    }
+    get state() {
+        if (!this._state) {
+            this._state = {};
+        }
+        return this._state;
+    }
+    set state(v) {
+        this._state = v;
+    }
+    get ip() {
+        if (this._ip)
+            return this._ip;
+        this._ip = this.req.socket.remoteAddress || '';
+        return this._ip;
+    }
+    // Setter for manual override if needed (though usually read-only from socket)
+    set ip(v) {
+        this._ip = v;
+    }
+    get url() {
+        if (this._url)
+            return this._url;
+        const host = this.headers.host || 'localhost';
+        this._url = new url_1.URL(this.req.url || '/', `http://${host}`);
+        return this._url;
+    }
+    set url(v) {
+        this._url = v;
+    }
+    json(payload, status = 200) {
+        const res = this.res;
+        let body;
+        if (this.serializer) {
+            body = this.serializer(payload);
+        }
+        else if (this._appJsonSerializer) {
+            body = this._appJsonSerializer(payload);
+        }
+        else {
+            // Native JSON.stringify is faster for schema-less objects
+            body = JSON.stringify(payload);
+        }
+        if (!res.headersSent) {
+            res.statusCode = status;
+            res.setHeader('content-type', 'application/json; charset=utf-8');
+        }
+        res.end(body);
+    }
+    send(payload, status = 200) {
+        const res = this.res;
+        if (!res.headersSent) {
+            res.statusCode = status;
+        }
+        res.end(payload);
+    }
+    html(payload, status = 200) {
+        const res = this.res;
+        if (!res.headersSent) {
+            res.statusCode = status;
+            res.setHeader('content-type', 'text/html; charset=utf-8');
+        }
+        res.end(payload);
+    }
+    redirect(url, status = 302) {
+        const res = this.res;
+        if (!res.headersSent) {
+            res.statusCode = status;
+            res.setHeader('Location', url);
+        }
+        res.end();
+    }
+    setCookie(name, value, options) {
+        const res = this.res;
+        const serialized = (0, cookies_1.serializeCookie)(name, value, options);
+        let existing = res.getHeader('Set-Cookie');
+        if (Array.isArray(existing)) {
+            existing.push(serialized);
+            res.setHeader('Set-Cookie', existing);
+        }
+        else if (existing) {
+            res.setHeader('Set-Cookie', [existing, serialized]);
+        }
+        else {
+            res.setHeader('Set-Cookie', serialized);
+        }
+    }
+    async render(view, locals) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const engine = this._app.options.viewEngine;
+        if (!engine) {
+            throw new Error('No view engine registered');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const viewsPath = this._app.options.viewsPath || process.cwd();
+        const fullPath = path_1.default.resolve(viewsPath, view);
+        const html = await engine.render(fullPath, locals || {});
+        const res = this.res;
+        if (!res.headersSent) {
+            res.statusCode = 200;
+            res.setHeader('content-type', 'text/html; charset=utf-8');
+        }
+        res.end(html);
+    }
+    async validate(schema, data) {
+        const target = data ?? this.body;
+        const result = await this._app.validator.validate(schema, target);
+        if (result.success) {
+            return result.data;
+        }
+        throw new types_1.HttpError(400, 'Validation Error', {
+            code: 'VALIDATION_ERROR',
+            details: result.error,
+        });
+    }
+    reset() {
+        this.req = null;
+        this.res = null;
+        this.headers = null;
+        this._url = null;
+        this.method = null;
+        this._ip = undefined;
+        this.params = null;
+        this.query = null;
+        this.body = undefined;
+        this.files = undefined;
+        this.cookies = null;
+        this._state = undefined;
+        this.requestId = undefined;
+        this.requestStart = undefined;
+        this.serializer = undefined;
+        this.path = '';
+        this.disableAutoEnd = false;
+        this.error = undefined;
+    }
+}
+exports.QHTTPXContextImpl = QHTTPXContextImpl;
 class QHTTPX {
     constructor(options = {}) {
         this.middlewares = [];
@@ -34,6 +194,7 @@ class QHTTPX {
         this.onBeforeShutdownHooks = [];
         this.onShutdownHooks = [];
         this.nextRequestId = 1;
+        this.requestCounter = 0;
         this.options = options;
         this.logger = new logger_1.Logger({
             name: options.name,
@@ -49,6 +210,7 @@ class QHTTPX {
         this.wsManager = new websocket_1.WebSocketManager(this.generateRequestId.bind(this));
         this.bufferPool = new buffer_pool_1.BufferPool(options.bufferPoolConfig);
         const maxConcurrency = options.maxConcurrency ?? 1024;
+        this.poolLimit = maxConcurrency * 2;
         this.scheduler = new scheduler_1.Scheduler({
             maxConcurrency,
         });
@@ -167,6 +329,7 @@ class QHTTPX {
                 }
                 const currentIndex = index;
                 index += 1;
+                ctx.next = executeNext;
                 const result = middlewares[currentIndex](ctx, executeNext);
                 if (result && typeof result.then === 'function') {
                     await result;
@@ -301,8 +464,9 @@ class QHTTPX {
         const compiled = this.compileRoutePipeline(handler, schema);
         this.router.register(method, path, compiled, { ...options, schema });
     }
-    get(path, handlerOrOptions, handler) {
-        this.registerRoute('GET', path, handlerOrOptions, handler);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(path, arg1, arg2) {
+        this.registerRoute('GET', path, arg1, arg2);
     }
     post(path, handlerOrOptions, handler) {
         this.registerRoute('POST', path, handlerOrOptions, handler);
@@ -468,130 +632,28 @@ class QHTTPX {
         await this.runLifecycleHooks(this.onShutdownHooks);
     }
     createContext() {
-        const jsonSerializer = this.options.jsonSerializer;
-        const useFastStringify = jsonSerializer === undefined;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const ctx = {
-            req: null,
-            res: null,
-            headers: null,
-            url: null,
-            params: null,
-            query: null,
-            body: undefined,
-            cookies: null,
-            state: null,
-            bufferPool: this.bufferPool,
-            requestId: '',
-            requestStart: 0,
-            serializer: null,
-            path: '',
-            error: undefined,
-            db: this.options.database,
-        };
-        // Helper to get response object from closure-captured ctx
-        // We use arrow functions to ensure they don't depend on 'this' context at call site
-        // enabling destructuring like: ({ json }) => json(...)
-        ctx.json = (payload, status = 200) => {
-            const res = ctx.res;
-            if (!res.headersSent) {
-                res.statusCode = status;
-                res.setHeader('content-type', 'application/json; charset=utf-8');
-            }
-            let body;
-            if (ctx.serializer) {
-                body = ctx.serializer(payload);
-            }
-            else if (useFastStringify) {
-                body = (0, serializer_1.fastJsonStringify)(payload);
-            }
-            else if (jsonSerializer) {
-                body = jsonSerializer(payload);
-            }
-            else {
-                body = JSON.stringify(payload);
-            }
-            res.end(body);
-        };
-        ctx.send = (payload, status = 200) => {
-            const res = ctx.res;
-            if (!res.headersSent) {
-                res.statusCode = status;
-            }
-            res.end(payload);
-        };
-        ctx.html = (payload, status = 200) => {
-            const res = ctx.res;
-            if (!res.headersSent) {
-                res.statusCode = status;
-                res.setHeader('content-type', 'text/html; charset=utf-8');
-            }
-            res.end(payload);
-        };
-        ctx.redirect = (url, status = 302) => {
-            const res = ctx.res;
-            if (!res.headersSent) {
-                res.statusCode = status;
-                res.setHeader('Location', url);
-            }
-            res.end();
-        };
-        ctx.setCookie = (name, value, options) => {
-            const res = ctx.res;
-            const serialized = (0, cookies_1.serializeCookie)(name, value, options);
-            let existing = res.getHeader('Set-Cookie');
-            if (Array.isArray(existing)) {
-                existing.push(serialized);
-                res.setHeader('Set-Cookie', existing);
-            }
-            else if (existing) {
-                res.setHeader('Set-Cookie', [existing, serialized]);
-            }
-            else {
-                res.setHeader('Set-Cookie', serialized);
-            }
-        };
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ctx.render = async (view, locals) => {
-            const engine = this.options.viewEngine;
-            if (!engine) {
-                throw new Error('No view engine registered');
-            }
-            const viewsPath = this.options.viewsPath || process.cwd();
-            const fullPath = path_1.default.resolve(viewsPath, view);
-            const html = await engine.render(fullPath, locals || {});
-            const res = ctx.res;
-            if (!res.headersSent) {
-                res.statusCode = 200;
-                res.setHeader('content-type', 'text/html; charset=utf-8');
-            }
-            res.end(html);
-        };
-        ctx.validate = async (schema, data) => {
-            const target = data ?? ctx.body;
-            const result = await this.validator.validate(schema, target);
-            if (result.success) {
-                return result.data;
-            }
-            throw new types_1.HttpError(400, 'Validation Error', {
-                code: 'VALIDATION_ERROR',
-                details: result.error,
-            });
-        };
-        return ctx;
+        return new QHTTPXContextImpl(this);
     }
-    acquireContext(req, res, url, params, query, requestId, body, 
+    acquireContext(req, res, urlOrPath, params, query, requestId, body, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     files) {
         const ctx = this.contextPool.pop() ?? this.createContext();
         // Reset and populate properties
         // We use type assertions to write to readonly/managed properties for performance
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const mutableCtx = ctx;
         mutableCtx.req = req;
         mutableCtx.res = res;
         mutableCtx.headers = req.headers;
-        mutableCtx.url = url;
+        if (typeof urlOrPath === 'string') {
+            // Ultra mode or fast path: Lazy URL instantiation
+            mutableCtx.path = urlOrPath;
+            // Class-based getter handles URL parsing lazily using this.req
+        }
+        else {
+            mutableCtx.url = urlOrPath;
+            mutableCtx.path = urlOrPath.pathname;
+        }
+        mutableCtx.method = req.method;
         mutableCtx.params = params;
         mutableCtx.query = query;
         mutableCtx.body = body;
@@ -602,88 +664,181 @@ class QHTTPX {
         if (!this.ultraMode) {
             mutableCtx.cookies = (0, cookies_1.parseCookies)(req.headers.cookie);
         }
-        mutableCtx.state = {};
         mutableCtx.disableAutoEnd = false;
-        mutableCtx.path = url.pathname;
-        return ctx;
+        return mutableCtx;
     }
     releaseContext(ctx) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const mutableCtx = ctx;
-        mutableCtx.req = null;
-        mutableCtx.res = null;
-        mutableCtx.headers = null;
-        mutableCtx.url = null;
-        mutableCtx.params = null;
-        mutableCtx.query = null;
-        mutableCtx.body = undefined;
-        mutableCtx.files = undefined;
-        mutableCtx.requestId = '';
-        mutableCtx.requestStart = 0;
-        mutableCtx.serializer = null;
-        mutableCtx.cookies = null;
-        mutableCtx.state = null;
-        mutableCtx.path = '';
-        mutableCtx.error = undefined;
-        // render method is static per context instance creation (closure over options), 
-        // but good to keep it consistent.
-        // Wait, 'render' is defined in 'createContext' and depends on 'this.options'.
-        // It doesn't hold request-specific state other than 'res' which is updated in 'acquireContext'.
-        // So we don't need to null it out.
-        if (this.contextPool.length < (this.options.maxConcurrency ?? 1024)) {
+        mutableCtx.reset();
+        if (this.contextPool.length < this.poolLimit) {
             this.contextPool.push(ctx);
         }
     }
-    async handleRequest(req, res) {
+    async handleNoMatch(ctx, allowedMethods) {
+        const res = ctx.res;
+        const hasAnyMethod = allowedMethods.length > 0;
+        if (hasAnyMethod && this.methodNotAllowedHandler) {
+            const result = this.methodNotAllowedHandler(ctx, allowedMethods);
+            if (result && typeof result.then === 'function') {
+                await result;
+            }
+            if (!res.writableEnded && !res.headersSent) {
+                res.statusCode = 405;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+                res.end('Method Not Allowed');
+            }
+        }
+        else if (!hasAnyMethod && this.notFoundHandler) {
+            const result = this.notFoundHandler(ctx);
+            if (result && typeof result.then === 'function') {
+                await result;
+            }
+            if (!res.writableEnded && !res.headersSent) {
+                res.statusCode = 404;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+                res.end('Not Found');
+            }
+        }
+        else if (hasAnyMethod) {
+            if (!res.headersSent) {
+                res.statusCode = 405;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+            }
+            res.end('Method Not Allowed');
+        }
+        else {
+            if (!res.headersSent) {
+                res.statusCode = 404;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+            }
+            res.end('Not Found');
+        }
+    }
+    handleRequest(req, res) {
+        // ⚡ Ultra Mode Optimization: Flattened & Inlined Logic
+        if (this.ultraMode) {
+            const rawUrl = req.url || '/';
+            const method = (req.method || 'GET');
+            // Single-pass pathname extraction
+            let pathname;
+            const qIndex = rawUrl.indexOf('?');
+            pathname = qIndex === -1 ? rawUrl : rawUrl.substring(0, qIndex);
+            const match = this.router.match(method, pathname);
+            if (match) {
+                // Acquire Context - reuse pooled object (no allocations)
+                const ctx = this.contextPool.pop() ?? this.createContext();
+                const mutableCtx = ctx;
+                mutableCtx.req = req;
+                mutableCtx.res = res;
+                mutableCtx.path = pathname;
+                mutableCtx.method = method;
+                mutableCtx.params = match.params || QHTTPX.EMPTY_PARAMS;
+                mutableCtx.query = EMPTY_QUERY;
+                mutableCtx.requestId = undefined;
+                mutableCtx.body = undefined;
+                mutableCtx.files = undefined;
+                mutableCtx.disableAutoEnd = false;
+                // Don't allocate state - leave as undefined
+                const releaseCtx = () => {
+                    mutableCtx.reset();
+                    if (this.contextPool.length < this.poolLimit) {
+                        this.contextPool.push(ctx);
+                    }
+                };
+                try {
+                    const result = match.handler(ctx);
+                    // Optimized promise detection
+                    if (result?.then) {
+                        result.then(() => {
+                            if (!res.writableEnded && !ctx.disableAutoEnd) {
+                                res.end();
+                            }
+                            releaseCtx();
+                        }).catch((err) => {
+                            console.error(err);
+                            if (!res.headersSent) {
+                                res.statusCode = 500;
+                                res.end();
+                            }
+                            releaseCtx();
+                        });
+                    }
+                    else {
+                        if (!res.writableEnded && !ctx.disableAutoEnd) {
+                            res.end();
+                        }
+                        releaseCtx();
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                    if (!res.headersSent) {
+                        res.statusCode = 500;
+                        res.end();
+                    }
+                    releaseCtx();
+                }
+            }
+            else {
+                // No match - Ultra Mode Fast 404
+                if (!res.headersSent) {
+                    res.statusCode = 404;
+                    res.end('Not Found');
+                }
+            }
+            return;
+        }
+        // === Balanced Mode Logic (Legacy) ===
         const rawMethod = (req.method || 'GET').toUpperCase();
         const method = rawMethod;
         const rawUrl = req.url || '/';
-        const host = req.headers.host || 'localhost';
-        const url = new url_1.URL(rawUrl, `http://${host}`);
-        const incomingRequestIdHeader = req.headers['x-request-id'];
-        let requestId;
-        if (typeof incomingRequestIdHeader === 'string') {
-            requestId = incomingRequestIdHeader;
-        }
-        else if (Array.isArray(incomingRequestIdHeader)) {
-            requestId = incomingRequestIdHeader[0];
+        // Fast path: parse URL without new URL() constructor (50-70x faster)
+        let pathname = rawUrl;
+        let query = EMPTY_QUERY;
+        const queryIndex = rawUrl.indexOf('?');
+        if (queryIndex !== -1) {
+            // Extract pathname
+            pathname = rawUrl.slice(0, queryIndex);
+            // Parse query string only if present
+            const queryString = rawUrl.slice(queryIndex + 1);
+            if (queryString.length > 0) {
+                const parsed = (0, querystring_1.parse)(queryString);
+                query = parsed;
+            }
         }
-        if (!requestId) {
-            requestId = this.generateRequestId();
+        else {
+            // No query string, just extract pathname
+            pathname = rawUrl;
         }
-        if (!res.headersSent && requestId) {
-            res.setHeader('x-request-id', requestId);
+        // Request ID generation
+        let requestId;
+        if (!this.ultraMode) {
+            const incomingRequestIdHeader = req.headers['x-request-id'];
+            if (typeof incomingRequestIdHeader === 'string') {
+                requestId = incomingRequestIdHeader;
+            }
+            else if (Array.isArray(incomingRequestIdHeader)) {
+                requestId = incomingRequestIdHeader[0];
+            }
+            if (!requestId) {
+                requestId = this.generateRequestId();
+            }
+            if (!res.headersSent && requestId) {
+                res.setHeader('x-request-id', requestId);
+            }
         }
-        let match = this.router.match(method, url.pathname);
+        let match = this.router.match(method, pathname);
         const hasRoute = !!match;
         if (!match) {
-            match = {
-                handler: () => { },
-                params: {},
-                priority: types_1.RoutePriority.STANDARD,
-            };
+            match = QHTTPX.EMPTY_MATCH;
         }
-        const allowedMethods = this.router.getAllowedMethods(url.pathname);
+        const allowedMethods = this.router.getAllowedMethods(pathname);
         if (!hasRoute && !res.headersSent) {
             const hasAnyMethod = allowedMethods.length > 0;
             res.statusCode = hasAnyMethod ? 405 : 404;
         }
-        const query = {};
-        url.searchParams.forEach((value, key) => {
-            if (Object.prototype.hasOwnProperty.call(query, key)) {
-                const existing = query[key];
-                if (Array.isArray(existing)) {
-                    existing.push(value);
-                }
-                else {
-                    query[key] = [existing, value];
-                }
-            }
-            else {
-                query[key] = value;
-            }
-        });
-        if (this.options.maxMemoryBytes !== undefined) {
+        // Memory Checks (throttled to every 100 requests for performance)
+        if (this.options.maxMemoryBytes !== undefined && ++this.requestCounter % 100 === 0) {
             const sampleRss = process.memoryUsage().rss;
             const overloadedByMemory = (0, resources_1.isResourceOverloaded)({ rssBytes: sampleRss }, { maxRssBytes: this.options.maxMemoryBytes });
             if (overloadedByMemory) {
@@ -701,17 +856,15 @@ class QHTTPX {
                 return;
             }
         }
-        let body;
-        let files;
+        else {
+            ++this.requestCounter;
+        }
         if (method !== 'GET' && method !== 'HEAD') {
-            try {
-                const parsed = await body_parser_1.BodyParser.parse(req, {
-                    maxBodyBytes: this.options.maxBodyBytes,
-                });
-                body = parsed.body;
-                files = parsed.files;
-            }
-            catch (err) {
+            body_parser_1.BodyParser.parse(req, {
+                maxBodyBytes: this.options.maxBodyBytes,
+            }).then((parsed) => {
+                this.dispatch(req, res, method, pathname, query, requestId, match, hasRoute, allowedMethods, parsed.body, parsed.files);
+            }).catch((err) => {
                 if (err instanceof Error && err.message === 'QHTTPX_INVALID_JSON') {
                     if (!res.headersSent) {
                         res.statusCode = 400;
@@ -733,10 +886,14 @@ class QHTTPX {
                     res.setHeader('content-type', 'text/plain; charset=utf-8');
                 }
                 res.end('Internal Server Error');
-                return;
-            }
+            });
+            return;
         }
-        const ctx = this.acquireContext(req, res, url, match.params, query, requestId, body, files);
+        this.dispatch(req, res, method, pathname, query, requestId, match, hasRoute, allowedMethods, undefined, undefined);
+    }
+    dispatch(req, res, method, pathname, query, requestId, match, hasRoute, allowedMethods, body, files) {
+        const ctx = this.acquireContext(req, res, pathname, match.params, query, requestId, body, files);
+        // Balanced Mode Logic
         const overloaded = () => {
             if (res.writableEnded) {
                 return;
@@ -761,14 +918,12 @@ class QHTTPX {
         };
         const start = Date.now();
         ctx.requestStart = start;
-        if (!this.ultraMode) {
-            this.metrics.onRequestStart();
-        }
+        this.metrics.onRequestStart();
         if (this.tracer) {
             const event = {
                 type: 'request_start',
                 method,
-                path: url.pathname,
+                path: pathname,
                 requestId,
             };
             const result = this.tracer(event);
@@ -776,61 +931,43 @@ class QHTTPX {
                 void result;
             }
         }
+        const finish = () => {
+            const duration = Date.now() - start;
+            this.metrics.onRequestEnd(duration, res.statusCode);
+            if (timedOut) {
+                this.metrics.onTimeout();
+            }
+            if (this.tracer) {
+                const event = {
+                    type: 'request_end',
+                    method,
+                    path: pathname,
+                    statusCode: res.statusCode,
+                    durationMs: duration,
+                    requestId,
+                };
+                const result = this.tracer(event);
+                if (result && typeof result.then === 'function') {
+                    void result;
+                }
+            }
+            this.releaseContext(ctx);
+        };
         const handle = async () => {
             const handler = match.handler;
             try {
                 if (hasRoute) {
-                    // Optimized path: Route handler is already compiled with middlewares
                     const result = handler(ctx);
                     if (result && typeof result.then === 'function') {
                         await result;
                     }
                 }
                 else if (this.pipelineRunner) {
-                    // Slow path: Run global middleware pipeline for 404/405
                     await this.pipelineRunner(ctx, handler);
                 }
                 if (!res.writableEnded) {
                     if (!hasRoute) {
-                        const hasAnyMethod = allowedMethods.length > 0;
-                        if (hasAnyMethod && this.methodNotAllowedHandler) {
-                            const result = this.methodNotAllowedHandler(ctx, allowedMethods);
-                            if (result &&
-                                typeof result.then === 'function') {
-                                await result;
-                            }
-                            if (!res.writableEnded && !res.headersSent) {
-                                res.statusCode = 405;
-                                res.setHeader('content-type', 'text/plain; charset=utf-8');
-                                res.end('Method Not Allowed');
-                            }
-                        }
-                        else if (!hasAnyMethod && this.notFoundHandler) {
-                            const result = this.notFoundHandler(ctx);
-                            if (result &&
-                                typeof result.then === 'function') {
-                                await result;
-                            }
-                            if (!res.writableEnded && !res.headersSent) {
-                                res.statusCode = 404;
-                                res.setHeader('content-type', 'text/plain; charset=utf-8');
-                                res.end('Not Found');
-                            }
-                        }
-                        else if (hasAnyMethod) {
-                            if (!res.headersSent) {
-                                res.statusCode = 405;
-                                res.setHeader('content-type', 'text/plain; charset=utf-8');
-                            }
-                            res.end('Method Not Allowed');
-                        }
-                        else {
-                            if (!res.headersSent) {
-                                res.statusCode = 404;
-                                res.setHeader('content-type', 'text/plain; charset=utf-8');
-                            }
-                            res.end('Not Found');
-                        }
+                        await this.handleNoMatch(ctx, allowedMethods);
                     }
                     else if (!ctx.disableAutoEnd) {
                         res.end();
@@ -841,39 +978,24 @@ class QHTTPX {
                 await this.handleError(err, ctx);
             }
         };
+        // Ultra mode: skip scheduler for minimal overhead
         if (this.ultraMode) {
-            await handle();
+            handle().then(finish).catch((err) => {
+                console.error('Request handler error:', err);
+                finish();
+            });
         }
         else {
-            await this.scheduler.run(handle, {
+            this.scheduler.run(handle, {
                 priority: match.priority,
                 onOverloaded: overloaded,
                 timeoutMs: this.options.requestTimeoutMs,
                 onTimeout,
+            }).then(finish).catch((err) => {
+                console.error('Scheduler error:', err);
+                finish();
             });
         }
-        const duration = Date.now() - start;
-        if (!this.ultraMode) {
-            this.metrics.onRequestEnd(duration, res.statusCode);
-            if (timedOut) {
-                this.metrics.onTimeout();
-            }
-        }
-        if (this.tracer) {
-            const event = {
-                type: 'request_end',
-                method,
-                path: url.pathname,
-                statusCode: res.statusCode,
-                durationMs: duration,
-                requestId,
-            };
-            const result = this.tracer(event);
-            if (result && typeof result.then === 'function') {
-                void result;
-            }
-        }
-        this.releaseContext(ctx);
     }
     async handleUpgrade(req, socket, head) {
         await this.wsManager.handleUpgrade(req, socket, head);
@@ -952,3 +1074,9 @@ class QHTTPX {
     }
 }
 exports.QHTTPX = QHTTPX;
+QHTTPX.EMPTY_PARAMS = Object.freeze({});
+QHTTPX.EMPTY_MATCH = Object.freeze({
+    handler: () => { },
+    params: QHTTPX.EMPTY_PARAMS,
+    priority: types_1.RoutePriority.STANDARD,
+});