qhttpx 1.8.12 → 1.9.1

package/dist/src/core/server.js

@@ -1,1082 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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");
-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 = [];
-        this.contextPool = [];
-        this.pipelineRunner = null;
-        this.onStartHooks = [];
-        this.onBeforeShutdownHooks = [];
-        this.onShutdownHooks = [];
-        this.nextRequestId = 1;
-        this.requestCounter = 0;
-        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.poolLimit = maxConcurrency * 2;
-        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);
-    }
-    /**
-     * Alias for setErrorHandler
-     */
-    onError(handler) {
-        this.setErrorHandler(handler);
-    }
-    /**
-     * Alias for setNotFoundHandler
-     */
-    notFound(handler) {
-        this.setNotFoundHandler(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;
-                ctx.next = executeNext;
-                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) => {
-                const nextFn = async () => {
-                    const result = next(ctx);
-                    if (result && typeof result.then === 'function') {
-                        await result;
-                    }
-                };
-                // Attach next to ctx for destructuring support
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ctx.next = nextFn;
-                return middleware(ctx, nextFn);
-            };
-        }
-        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, handlerIfOptions) {
-        let handler;
-        let schema;
-        const options = {};
-        if (typeof handlerOrOptions === 'function') {
-            handler = handlerOrOptions;
-        }
-        else if (handlerIfOptions) {
-            handler = handlerIfOptions;
-            schema = handlerOrOptions.schema;
-            options.priority = handlerOrOptions.priority;
-        }
-        else {
-            const opts = handlerOrOptions;
-            handler = opts.handler;
-            schema = opts.schema;
-            options.priority = opts.priority;
-        }
-        const compiled = this.compileRoutePipeline(handler, schema);
-        this.router.register(method, path, compiled, { ...options, schema });
-    }
-    // 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);
-    }
-    put(path, handlerOrOptions, handler) {
-        this.registerRoute('PUT', path, handlerOrOptions, handler);
-    }
-    delete(path, handlerOrOptions, handler) {
-        this.registerRoute('DELETE', path, handlerOrOptions, 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, hostnameOrCallback, callback) {
-        let hostname;
-        let cb;
-        if (typeof hostnameOrCallback === 'function') {
-            cb = hostnameOrCallback;
-            hostname = undefined;
-        }
-        else {
-            hostname = hostnameOrCallback;
-            cb = callback;
-        }
-        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 (cb)
-                    cb();
-                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() {
-        return new QHTTPXContextImpl(this);
-    }
-    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
-        const mutableCtx = ctx;
-        mutableCtx.req = req;
-        mutableCtx.res = res;
-        mutableCtx.headers = req.headers;
-        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;
-        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.disableAutoEnd = false;
-        return mutableCtx;
-    }
-    releaseContext(ctx) {
-        const mutableCtx = ctx;
-        mutableCtx.reset();
-        if (this.contextPool.length < this.poolLimit) {
-            this.contextPool.push(ctx);
-        }
-    }
-    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 || '/';
-        // 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;
-            }
-        }
-        else {
-            // No query string, just extract pathname
-            pathname = rawUrl;
-        }
-        // 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, pathname);
-        const hasRoute = !!match;
-        if (!match) {
-            match = QHTTPX.EMPTY_MATCH;
-        }
-        const allowedMethods = this.router.getAllowedMethods(pathname);
-        if (!hasRoute && !res.headersSent) {
-            const hasAnyMethod = allowedMethods.length > 0;
-            res.statusCode = hasAnyMethod ? 405 : 404;
-        }
-        // 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) {
-                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;
-            }
-        }
-        else {
-            ++this.requestCounter;
-        }
-        if (method !== 'GET' && method !== 'HEAD') {
-            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;
-                        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;
-        }
-        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;
-            }
-            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;
-        this.metrics.onRequestStart();
-        if (this.tracer) {
-            const event = {
-                type: 'request_start',
-                method,
-                path: pathname,
-                requestId,
-            };
-            const result = this.tracer(event);
-            if (result && typeof result.then === 'function') {
-                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) {
-                    const result = handler(ctx);
-                    if (result && typeof result.then === 'function') {
-                        await result;
-                    }
-                }
-                else if (this.pipelineRunner) {
-                    await this.pipelineRunner(ctx, handler);
-                }
-                if (!res.writableEnded) {
-                    if (!hasRoute) {
-                        await this.handleNoMatch(ctx, allowedMethods);
-                    }
-                    else if (!ctx.disableAutoEnd) {
-                        res.end();
-                    }
-                }
-            }
-            catch (err) {
-                await this.handleError(err, ctx);
-            }
-        };
-        // Ultra mode: skip scheduler for minimal overhead
-        if (this.ultraMode) {
-            handle().then(finish).catch((err) => {
-                console.error('Request handler error:', err);
-                finish();
-            });
-        }
-        else {
-            this.scheduler.run(handle, {
-                priority: match.priority,
-                onOverloaded: overloaded,
-                timeoutMs: this.options.requestTimeoutMs,
-                onTimeout,
-            }).then(finish).catch((err) => {
-                console.error('Scheduler error:', err);
-                finish();
-            });
-        }
-    }
-    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
-            }
-        }
-    }
-    handleError(err, ctx) {
-        const res = ctx.res;
-        if (res.writableEnded) {
-            return;
-        }
-        if (this.errorHandler) {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const errorContext = ctx;
-                errorContext.error = err;
-                const result = this.errorHandler(errorContext);
-                if (result && typeof result.then === 'function') {
-                    return result.then(() => {
-                        // Ensure response is sent if handler didn't
-                    });
-                }
-                if (res.writableEnded) {
-                    return;
-                }
-            }
-            catch (handlerErr) {
-                // Fall through to default error handling below
-                console.error('Error in error handler:', handlerErr);
-            }
-        }
-        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;
-QHTTPX.EMPTY_PARAMS = Object.freeze({});
-QHTTPX.EMPTY_MATCH = Object.freeze({
-    handler: () => { },
-    params: QHTTPX.EMPTY_PARAMS,
-    priority: types_1.RoutePriority.STANDARD,
-});