qhttpx 1.8.0

package/dist/src/core/server.js

@@ -0,0 +1,905 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QHTTPX = void 0;
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const package_json_1 = __importDefault(require("../../package.json"));
+const router_1 = require("../router/router");
+const scheduler_1 = require("./scheduler");
+const tasks_1 = require("./tasks");
+const resources_1 = require("./resources");
+const metrics_1 = require("./metrics");
+const body_parser_1 = require("./body-parser");
+const buffer_pool_1 = require("./buffer-pool");
+const websocket_1 = require("./websocket");
+const serializer_1 = require("./serializer");
+const batch_1 = require("./batch");
+const fusion_1 = require("./fusion");
+const simple_1 = require("../validation/simple");
+const generator_1 = require("../openapi/generator");
+const types_1 = require("./types");
+const cookies_1 = require("../utils/cookies");
+const scope_1 = require("./scope");
+const logger_1 = require("./logger");
+class QHTTPX {
+    constructor(options = {}) {
+        this.middlewares = [];
+        this.contextPool = [];
+        this.pipelineRunner = null;
+        this.onStartHooks = [];
+        this.onBeforeShutdownHooks = [];
+        this.onShutdownHooks = [];
+        this.nextRequestId = 1;
+        this.options = options;
+        this.logger = new logger_1.Logger({
+            name: options.name,
+            level: options.performanceMode === 'ultra' ? 'error' : 'info'
+        });
+        this.ultraMode = options.performanceMode === 'ultra';
+        this.errorHandler = this.ultraMode ? undefined : options.errorHandler;
+        this.notFoundHandler = this.ultraMode ? undefined : options.notFoundHandler;
+        this.methodNotAllowedHandler = this.ultraMode ? undefined : options.methodNotAllowedHandler;
+        this.tracer = this.ultraMode ? undefined : options.tracer;
+        this.workerCount = (0, resources_1.calculateWorkerCount)(options.workers ?? 'auto');
+        this.router = new router_1.Router();
+        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.scheduler = new scheduler_1.Scheduler({
+            maxConcurrency,
+        });
+        this.tasks = new tasks_1.TaskEngine(this.scheduler);
+        if (options.enableBatching) {
+            this.batchExecutor = new batch_1.BatchExecutor(options.database);
+        }
+        if (options.enableRequestFusion) {
+            this.fusion = new fusion_1.RequestFusion(options.enableRequestFusion);
+        }
+        this.validator = options.validator ?? new simple_1.SimpleValidator();
+        this.metrics = new metrics_1.Metrics(this.scheduler, {
+            enabled: !this.ultraMode && (this.options.metricsEnabled ?? true),
+        }, this.tasks);
+        for (let i = 0; i < maxConcurrency; i += 1) {
+            this.contextPool.push(this.createContext());
+        }
+        this.registerInternalRoutes();
+        this.compileMiddlewarePipeline();
+        this.server = http_1.default.createServer(this.handleRequest.bind(this));
+        if (this.options.keepAliveTimeoutMs !== undefined) {
+            this.server.keepAliveTimeout = this.options.keepAliveTimeoutMs;
+        }
+        else if (this.ultraMode) {
+            this.server.keepAliveTimeout = 0;
+        }
+        if (this.options.headersTimeoutMs !== undefined) {
+            this.server.headersTimeout = this.options.headersTimeoutMs;
+        }
+        else if (this.ultraMode) {
+            this.server.headersTimeout = 0;
+        }
+        if (this.ultraMode) {
+            this.server.requestTimeout = 0;
+            this.server.maxHeadersCount = 0;
+            this.server.timeout = 0;
+        }
+        this.server.on('upgrade', (req, socket, head) => {
+            void this.handleUpgrade(req, socket, head);
+        });
+    }
+    get serverInstance() {
+        return this.server;
+    }
+    get websocket() {
+        return this.wsManager;
+    }
+    setErrorHandler(handler) {
+        this.errorHandler = handler;
+    }
+    setNotFoundHandler(handler) {
+        this.notFoundHandler = handler;
+    }
+    setMethodNotAllowedHandler(handler) {
+        this.methodNotAllowedHandler = handler;
+    }
+    set404Handler(handler) {
+        this.setNotFoundHandler(handler);
+    }
+    set405Handler(handler) {
+        this.setMethodNotAllowedHandler(handler);
+    }
+    onStart(hook) {
+        this.onStartHooks.push(hook);
+    }
+    onBeforeShutdown(hook) {
+        this.onBeforeShutdownHooks.push(hook);
+    }
+    onShutdown(hook) {
+        this.onShutdownHooks.push(hook);
+    }
+    upgrade(path, handler) {
+        this.wsManager.register(path, handler);
+    }
+    use(middleware) {
+        this.middlewares.push(middleware);
+        // Recompile pipeline after middleware is added
+        this.compileMiddlewarePipeline();
+    }
+    compileMiddlewarePipeline() {
+        const middlewares = this.middlewares;
+        if (middlewares.length === 0) {
+            this.pipelineRunner = async (ctx, handler) => {
+                const result = handler(ctx);
+                if (result && typeof result.then === 'function') {
+                    await result;
+                }
+            };
+            return;
+        }
+        // Flatten middleware pipeline into a single function chain
+        // This eliminates Promise nesting, recursive dispatch overhead, and microtask backlogs
+        // Each middleware executes directly without closure allocation overhead
+        this.pipelineRunner = async (ctx, handler) => {
+            let index = 0;
+            const executeNext = async () => {
+                if (index >= middlewares.length) {
+                    // All middlewares done, execute handler
+                    const result = handler(ctx);
+                    if (result && typeof result.then === 'function') {
+                        await result;
+                    }
+                    return;
+                }
+                const currentIndex = index;
+                index += 1;
+                const result = middlewares[currentIndex](ctx, executeNext);
+                if (result && typeof result.then === 'function') {
+                    await result;
+                }
+            };
+            await executeNext();
+        };
+    }
+    compileRoutePipeline(handler, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    schema) {
+        const middlewares = this.middlewares;
+        // Heuristic: Is it a structured RouteSchema or a legacy ResponseSchema?
+        let responseSchema;
+        let requestSchema;
+        if (schema) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const s = schema;
+            if (s.body || s.query || s.params || s.headers || s.response) {
+                // It is a RouteSchema
+                requestSchema = s;
+                responseSchema = s.response;
+            }
+            else {
+                // It is a legacy ResponseSchema
+                responseSchema = s;
+            }
+        }
+        const stringifier = responseSchema ? (0, serializer_1.getStringifier)(responseSchema) : undefined;
+        // Build middleware chain
+        let pipeline = handler;
+        // Wrap with validation if needed (before handler, after global middleware)
+        if (requestSchema) {
+            const inner = pipeline;
+            pipeline = async (ctx) => {
+                // Validate Body
+                if (requestSchema.body) {
+                    const result = await this.validator.validate(requestSchema.body, ctx.body);
+                    if (!result.success) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const err = result.error;
+                        ctx.json({ error: 'Validation Error', details: err.details || err.message || err }, 400);
+                        return;
+                    }
+                    ctx.body = result.data;
+                }
+                // Validate Query
+                if (requestSchema.query) {
+                    const result = await this.validator.validate(requestSchema.query, ctx.query);
+                    if (!result.success) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const err = result.error;
+                        ctx.json({ error: 'Validation Error', details: err.details || err.message || err }, 400);
+                        return;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    ctx.query = result.data;
+                }
+                // Validate Params
+                if (requestSchema.params) {
+                    const result = await this.validator.validate(requestSchema.params, ctx.params);
+                    if (!result.success) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const err = result.error;
+                        ctx.json({ error: 'Validation Error', details: err.details || err.message || err }, 400);
+                        return;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    ctx.params = result.data;
+                }
+                return inner(ctx);
+            };
+        }
+        // Wrap with Request Fusion if enabled
+        if (this.fusion) {
+            const inner = pipeline;
+            pipeline = (ctx) => this.fusion.coalesce(ctx, inner);
+        }
+        // We iterate backwards to wrap the handler
+        // pipeline = m[last](ctx, () => pipeline(ctx))
+        for (let i = middlewares.length - 1; i >= 0; i -= 1) {
+            const middleware = middlewares[i];
+            const next = pipeline;
+            pipeline = (ctx) => {
+                return middleware(ctx, async () => {
+                    const result = next(ctx);
+                    if (result && typeof result.then === 'function') {
+                        await result;
+                    }
+                });
+            };
+        }
+        if (stringifier) {
+            const inner = pipeline;
+            return (ctx) => {
+                ctx.serializer = stringifier;
+                return inner(ctx);
+            };
+        }
+        return pipeline;
+    }
+    // Internal registration to be accessed by Scopes
+    _registerRoute(method, path, handlerOrOptions) {
+        this.registerRoute(method, path, handlerOrOptions);
+    }
+    async register(plugin, options) {
+        const scope = new scope_1.QHTTPXScope(this, options?.prefix);
+        await plugin(scope, options);
+    }
+    registerRoute(method, path, handlerOrOptions) {
+        let handler;
+        let schema;
+        const options = {};
+        if (typeof handlerOrOptions === 'function') {
+            handler = handlerOrOptions;
+        }
+        else {
+            handler = handlerOrOptions.handler;
+            schema = handlerOrOptions.schema;
+            options.priority = handlerOrOptions.priority;
+        }
+        const compiled = this.compileRoutePipeline(handler, schema);
+        this.router.register(method, path, compiled, { ...options, schema });
+    }
+    get(path, handler) {
+        this.registerRoute('GET', path, handler);
+    }
+    post(path, handler) {
+        this.registerRoute('POST', path, handler);
+    }
+    put(path, handler) {
+        this.registerRoute('PUT', path, handler);
+    }
+    delete(path, handler) {
+        this.registerRoute('DELETE', path, handler);
+    }
+    route(path) {
+        const register = (method, handler) => {
+            this.registerRoute(method, path, handler);
+        };
+        const builder = {
+            get(handler) {
+                register('GET', handler);
+                return this;
+            },
+            post(handler) {
+                register('POST', handler);
+                return this;
+            },
+            put(handler) {
+                register('PUT', handler);
+                return this;
+            },
+            delete(handler) {
+                register('DELETE', handler);
+                return this;
+            },
+        };
+        return builder;
+    }
+    task(name, handler, options) {
+        this.tasks.register(name, handler, options);
+    }
+    enqueue(name, payload) {
+        return this.tasks.enqueue(name, payload);
+    }
+    op(name, handler) {
+        if (!this.batchExecutor) {
+            // Auto-enable batch executor if op is called?
+            // Or throw?
+            // Better to throw or warn if not enabled.
+            // But for ease of use, let's create it if missing (but we miss DB context if done this way without options)
+            // The constructor handles options. If enableBatching is false, we shouldn't be here.
+            throw new Error('Batching is not enabled. Pass enableBatching: true to QHTTPX options.');
+        }
+        this.batchExecutor.register(name, handler);
+    }
+    registerInternalRoutes() {
+        this.router.register('GET', '/__qhttpx/health', (ctx) => {
+            const version = typeof package_json_1.default.version === 'string' ? package_json_1.default.version : '';
+            const name = typeof package_json_1.default.name === 'string' ? package_json_1.default.name : '';
+            ctx.json({
+                status: 'ok',
+                name,
+                version,
+                workers: this.workerCount,
+            });
+        });
+        this.router.register('GET', '/__qhttpx/metrics', (ctx) => {
+            const snapshot = this.metrics.snapshot();
+            ctx.json({
+                ...snapshot,
+                workers: this.workerCount,
+            });
+        });
+        this.router.register('GET', '/__qhttpx/runtime', (ctx) => {
+            const schedulerStats = this.scheduler.getStats();
+            ctx.json({
+                workers: this.workerCount,
+                router: {
+                    frozen: this.router.isFrozenRouter(),
+                },
+                scheduler: schedulerStats,
+            });
+        });
+        if (this.options.enableBatching && this.batchExecutor) {
+            const endpoint = typeof this.options.enableBatching === 'object'
+                ? this.options.enableBatching.endpoint
+                : '/qhttpx';
+            this.router.register('POST', endpoint, async (ctx) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const body = ctx.body;
+                if (!body || !Array.isArray(body.batch)) {
+                    ctx.json({ error: 'Invalid batch format' }, 400);
+                    return;
+                }
+                try {
+                    const result = await this.batchExecutor.handleBatch(ctx, body.batch);
+                    ctx.json(result);
+                }
+                catch (err) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    ctx.json({ error: err.message }, 500);
+                }
+            });
+        }
+    }
+    getOpenAPI(options) {
+        const generator = new generator_1.OpenAPIGenerator(this.router, options);
+        return generator.generate();
+    }
+    async listen(port, hostname) {
+        if (this.options.database) {
+            await this.options.database.connect();
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (this.options.plugins) {
+            // Plugins are registered synchronously in constructor, but their async init happens now?
+            // Actually, plugins are registered via app.register() which is async.
+            // So they should be ready.
+        }
+        return new Promise((resolve, reject) => {
+            const onError = (error) => {
+                this.server.off('error', onError);
+                reject(error);
+            };
+            this.server.once('error', onError);
+            this.server.listen(port, hostname, () => {
+                this.server.off('error', onError);
+                // Freeze router after server starts to prevent further registrations
+                this.router.freeze();
+                void this.runLifecycleHooks(this.onStartHooks);
+                const address = this.server.address();
+                if (address && typeof address === 'object') {
+                    resolve({ port: address.port });
+                }
+                else {
+                    resolve({ port });
+                }
+            });
+        });
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async shutdown() {
+        await this.runLifecycleHooks(this.onBeforeShutdownHooks);
+        await this.close();
+        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,
+            url: null,
+            params: null,
+            query: null,
+            body: undefined,
+            cookies: null,
+            state: null,
+            bufferPool: this.bufferPool,
+            requestId: '',
+            requestStart: 0,
+            serializer: null,
+            json(payload, status = 200) {
+                const res = this.res;
+                if (!res.headersSent) {
+                    res.statusCode = status;
+                    res.setHeader('content-type', 'application/json; charset=utf-8');
+                }
+                let body;
+                if (this.serializer) {
+                    body = this.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);
+            },
+            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);
+                }
+            },
+            db: this.options.database,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            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 || {});
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const res = ctx.res;
+                if (!res.headersSent) {
+                    res.statusCode = 200;
+                    res.setHeader('content-type', 'text/html; charset=utf-8');
+                }
+                res.end(html);
+            },
+            validate: async (schema, data) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                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;
+    }
+    acquireContext(req, res, url, 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.url = url;
+        mutableCtx.params = params;
+        mutableCtx.query = query;
+        mutableCtx.body = body;
+        mutableCtx.files = files;
+        mutableCtx.requestId = requestId;
+        mutableCtx.serializer = undefined;
+        // In ultra mode, skip cookie parsing to save overhead
+        if (!this.ultraMode) {
+            mutableCtx.cookies = (0, cookies_1.parseCookies)(req.headers.cookie);
+        }
+        mutableCtx.state = {};
+        mutableCtx.disableAutoEnd = false;
+        return ctx;
+    }
+    releaseContext(ctx) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mutableCtx = ctx;
+        mutableCtx.req = null;
+        mutableCtx.res = 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;
+        // 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)) {
+            this.contextPool.push(ctx);
+        }
+    }
+    async handleRequest(req, res) {
+        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];
+        }
+        if (!requestId) {
+            requestId = this.generateRequestId();
+        }
+        if (!res.headersSent && requestId) {
+            res.setHeader('x-request-id', requestId);
+        }
+        let match = this.router.match(method, url.pathname);
+        const hasRoute = !!match;
+        if (!match) {
+            match = {
+                handler: () => { },
+                params: {},
+                priority: types_1.RoutePriority.STANDARD,
+            };
+        }
+        const allowedMethods = this.router.getAllowedMethods(url.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) {
+            const sampleRss = process.memoryUsage().rss;
+            const overloadedByMemory = (0, resources_1.isResourceOverloaded)({ rssBytes: sampleRss }, { maxRssBytes: this.options.maxMemoryBytes });
+            if (overloadedByMemory) {
+                const overloaded = () => {
+                    if (res.writableEnded) {
+                        return;
+                    }
+                    if (!res.headersSent) {
+                        res.statusCode = 503;
+                        res.setHeader('content-type', 'text/plain; charset=utf-8');
+                    }
+                    res.end('Server overloaded');
+                };
+                overloaded();
+                return;
+            }
+        }
+        let body;
+        let files;
+        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) {
+                if (err instanceof Error && err.message === 'QHTTPX_INVALID_JSON') {
+                    if (!res.headersSent) {
+                        res.statusCode = 400;
+                        res.setHeader('content-type', 'text/plain; charset=utf-8');
+                    }
+                    res.end('Invalid JSON');
+                    return;
+                }
+                if (err instanceof Error && err.message === 'QHTTPX_BODY_TOO_LARGE') {
+                    if (!res.headersSent) {
+                        res.statusCode = 413;
+                        res.setHeader('content-type', 'text/plain; charset=utf-8');
+                    }
+                    res.end('Payload Too Large');
+                    return;
+                }
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                    res.setHeader('content-type', 'text/plain; charset=utf-8');
+                }
+                res.end('Internal Server Error');
+                return;
+            }
+        }
+        const ctx = this.acquireContext(req, res, url, match.params, query, requestId, body, files);
+        const overloaded = () => {
+            if (res.writableEnded) {
+                return;
+            }
+            if (!res.headersSent) {
+                res.statusCode = 503;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+            }
+            res.end('Server overloaded');
+        };
+        let timedOut = false;
+        const onTimeout = () => {
+            timedOut = true;
+            if (res.writableEnded) {
+                return;
+            }
+            if (!res.headersSent) {
+                res.statusCode = 504;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+            }
+            res.end('Request timed out');
+        };
+        const start = Date.now();
+        ctx.requestStart = start;
+        if (!this.ultraMode) {
+            this.metrics.onRequestStart();
+        }
+        if (this.tracer) {
+            const event = {
+                type: 'request_start',
+                method,
+                path: url.pathname,
+                requestId,
+            };
+            const result = this.tracer(event);
+            if (result && typeof result.then === 'function') {
+                void result;
+            }
+        }
+        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');
+                        }
+                    }
+                    else if (!ctx.disableAutoEnd) {
+                        res.end();
+                    }
+                }
+            }
+            catch (err) {
+                await this.handleError(err, ctx);
+            }
+        };
+        if (this.ultraMode) {
+            await handle();
+        }
+        else {
+            await this.scheduler.run(handle, {
+                priority: match.priority,
+                onOverloaded: overloaded,
+                timeoutMs: this.options.requestTimeoutMs,
+                onTimeout,
+            });
+        }
+        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);
+    }
+    async runLifecycleHooks(hooks) {
+        if (hooks.length === 0) {
+            return;
+        }
+        for (const hook of hooks) {
+            try {
+                const result = hook();
+                if (result && typeof result.then === 'function') {
+                    await result;
+                }
+            }
+            catch {
+                // Ignore hook errors to avoid impacting core server flow
+            }
+        }
+    }
+    async handleError(err, ctx) {
+        const res = ctx.res;
+        if (res.writableEnded) {
+            return;
+        }
+        if (this.errorHandler) {
+            try {
+                const result = this.errorHandler(err, ctx);
+                if (result && typeof result.then === 'function') {
+                    await result;
+                }
+                if (res.writableEnded) {
+                    return;
+                }
+            }
+            catch {
+                // Fall through to default error handling below
+            }
+        }
+        if (res.writableEnded) {
+            return;
+        }
+        if (err instanceof types_1.HttpError) {
+            if (!res.headersSent) {
+                res.statusCode = err.status;
+                res.setHeader('content-type', 'application/json; charset=utf-8');
+            }
+            const payload = {
+                error: {
+                    message: err.message,
+                    code: err.code ?? 'HTTP_ERROR',
+                    details: err.details,
+                },
+            };
+            const serializer = this.options.jsonSerializer;
+            const body = serializer !== undefined ? serializer(payload) : JSON.stringify(payload);
+            res.end(body);
+            return;
+        }
+        if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader('content-type', 'text/plain; charset=utf-8');
+        }
+        res.end('Internal Server Error');
+    }
+    generateRequestId() {
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        return `${Date.now().toString(36)}-${id.toString(36)}`;
+    }
+}
+exports.QHTTPX = QHTTPX;