@carno.js/core 1.0.2 → 1.0.3

package/dist/Carno.js

@@ -1,277 +1,474 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var Carno_exports = {};
-__export(Carno_exports, {
-  Carno: () => Carno
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Carno = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+// RadixRouter removed - using Bun's native SIMD-accelerated router
+const JITCompiler_1 = require("./compiler/JITCompiler");
+const Context_1 = require("./context/Context");
+const Container_1 = require("./container/Container");
+const CorsHandler_1 = require("./cors/CorsHandler");
+const HttpException_1 = require("./exceptions/HttpException");
+const ZodAdapter_1 = require("./validation/ZodAdapter");
+const Lifecycle_1 = require("./events/Lifecycle");
+const CacheService_1 = require("./cache/CacheService");
+const DefaultRoutes_1 = require("./DefaultRoutes");
+const ZodAdapter_2 = require("./validation/ZodAdapter");
+// CompiledRoute removed - handlers are registered directly in Bun's routes
+const NOT_FOUND_RESPONSE = new Response('Not Found', { status: 404 });
+/**
+ * Pre-computed response - frozen and reused.
+ */
+const TEXT_OPTS = Object.freeze({
+    status: 200,
+    headers: { 'Content-Type': 'text/plain' }
 });
-module.exports = __toCommonJS(Carno_exports);
-var import_reflect_metadata = require("reflect-metadata"), import_metadata = require('./metadata.js'), import_JITCompiler = require('./compiler/JITCompiler.js'), import_Context = require('./context/Context.js'), import_Container = require('./container/Container.js'), import_CorsHandler = require('./cors/CorsHandler.js'), import_HttpException = require('./exceptions/HttpException.js'), import_ZodAdapter = require('./validation/ZodAdapter.js'), import_Lifecycle = require('./events/Lifecycle.js'), import_CacheService = require('./cache/CacheService.js'), import_DefaultRoutes = require('./DefaultRoutes.js'), import_ZodAdapter2 = require('./validation/ZodAdapter.js');
-const NOT_FOUND_RESPONSE = new Response("Not Found", { status: 404 }), TEXT_OPTS = Object.freeze({
-  status: 200,
-  headers: { "Content-Type": "text/plain" }
-}), JSON_OPTS = Object.freeze({
-  status: 200,
-  headers: { "Content-Type": "application/json" }
-}), INTERNAL_ERROR_RESPONSE = new Response(
-  '{"statusCode":500,"message":"Internal Server Error"}',
-  { status: 500, headers: { "Content-Type": "application/json" } }
-);
+const JSON_OPTS = Object.freeze({
+    status: 200,
+    headers: { 'Content-Type': 'application/json' }
+});
+const INTERNAL_ERROR_RESPONSE = new Response('{"statusCode":500,"message":"Internal Server Error"}', { status: 500, headers: { 'Content-Type': 'application/json' } });
+// METHOD_MAP removed - Bun handles method routing natively
+/**
+ * Carno Application - Ultra-aggressive performance.
+ *
+ * ZERO runtime work in hot path:
+ * - All responses pre-created at startup
+ * - Direct Bun native routes - no fetch fallback needed
+ * - No function calls in hot path
+ */
 class Carno {
-  constructor(config = {}) {
-    this.config = config;
-    this._controllers = [];
-    this._services = [];
-    this._middlewares = [];
-    this.routes = {};
-    this.container = new import_Container.Container();
-    this.corsHandler = null;
-    this.hasCors = !1;
-    this.validator = null;
-    // Cached lifecycle event flags - checked once at startup
-    this.hasInitHooks = !1;
-    this.hasBootHooks = !1;
-    this.hasShutdownHooks = !1;
-    if (this.config.exports = this.config.exports || [], this.config.globalMiddlewares = this.config.globalMiddlewares || [], this.config.cors && (this.corsHandler = new import_CorsHandler.CorsHandler(this.config.cors), this.hasCors = !0), this.config.validation === void 0 || this.config.validation === !0)
-      this.validator = new import_ZodAdapter2.ZodAdapter();
-    else if (typeof this.config.validation == "function") {
-      const AdapterClass = this.config.validation;
-      this.validator = new AdapterClass();
-    } else this.config.validation && (this.validator = this.config.validation);
-  }
-  /**
-   * Use a Carno plugin.
-   * Imports controllers, services and global middlewares from another Carno instance.
-   */
-  use(plugin) {
-    plugin._controllers.length > 0 && this._controllers.push(...plugin._controllers);
-    for (const exported of plugin.config.exports || []) {
-      const existingService = this.findServiceInPlugin(plugin, exported), serviceToAdd = this.shouldCloneService(existingService) ? { ...existingService } : exported;
-      this._services.push(serviceToAdd);
+    constructor(config = {}) {
+        this.config = config;
+        this._controllers = [];
+        this._services = [];
+        this._middlewares = [];
+        this.routes = {};
+        this.container = new Container_1.Container();
+        this.corsHandler = null;
+        this.hasCors = false;
+        this.validator = null;
+        // Cached lifecycle event flags - checked once at startup
+        this.hasInitHooks = false;
+        this.hasBootHooks = false;
+        this.hasShutdownHooks = false;
+        this.config.exports = this.config.exports || [];
+        this.config.globalMiddlewares = this.config.globalMiddlewares || [];
+        // Initialize CORS handler if configured
+        if (this.config.cors) {
+            this.corsHandler = new CorsHandler_1.CorsHandler(this.config.cors);
+            this.hasCors = true;
+        }
+        // Initialize validator
+        // Default: ZodAdapter if undefined or true
+        if (this.config.validation === undefined || this.config.validation === true) {
+            this.validator = new ZodAdapter_2.ZodAdapter();
+        }
+        // Constructor class passed directly
+        else if (typeof this.config.validation === 'function') {
+            const AdapterClass = this.config.validation;
+            this.validator = new AdapterClass();
+        }
+        // Instance passed directly
+        else if (this.config.validation) {
+            this.validator = this.config.validation;
+        }
+    }
+    /**
+     * Use a Carno plugin.
+     * Imports controllers, services and global middlewares from another Carno instance.
+     */
+    use(plugin) {
+        // Import controllers from plugin
+        if (plugin._controllers.length > 0) {
+            this._controllers.push(...plugin._controllers);
+        }
+        // Import services from plugin exports
+        for (const exported of plugin.config.exports || []) {
+            const existingService = this.findServiceInPlugin(plugin, exported);
+            const serviceToAdd = this.shouldCloneService(existingService)
+                ? { ...existingService }
+                : exported;
+            this._services.push(serviceToAdd);
+        }
+        // Import services registered via .services() on the plugin
+        if (plugin._services.length > 0) {
+            this._services.push(...plugin._services);
+        }
+        // Import global middlewares
+        if (plugin.config.globalMiddlewares) {
+            this._middlewares.push(...plugin.config.globalMiddlewares);
+        }
+        // Import middlewares registered via .middlewares() on the plugin
+        if (plugin._middlewares.length > 0) {
+            this._middlewares.push(...plugin._middlewares);
+        }
+        return this;
+    }
+    findServiceInPlugin(plugin, exported) {
+        return plugin._services.find(s => this.getServiceToken(s) === this.getServiceToken(exported));
+    }
+    getServiceToken(service) {
+        return service?.token || service;
+    }
+    shouldCloneService(service) {
+        return !!(service?.useValue !== undefined || service?.useClass);
+    }
+    /**
+     * Register one or more services/providers.
+     */
+    services(serviceClass) {
+        const items = Array.isArray(serviceClass) ? serviceClass : [serviceClass];
+        this._services.push(...items);
+        return this;
+    }
+    /**
+     * Register one or more global middlewares.
+     */
+    middlewares(handler) {
+        const items = Array.isArray(handler) ? handler : [handler];
+        this._middlewares.push(...items);
+        return this;
+    }
+    /**
+     * Register one or more controllers.
+     */
+    controllers(controllerClass) {
+        const items = Array.isArray(controllerClass) ? controllerClass : [controllerClass];
+        this._controllers.push(...items);
+        return this;
+    }
+    /**
+     * Get a service instance from the container.
+     */
+    get(token) {
+        return this.container.get(token);
+    }
+    listen(port = 3000) {
+        this.bootstrap();
+        this.compileRoutes();
+        // All routes go through Bun's native SIMD-accelerated router
+        const config = {
+            port,
+            fetch: this.handleNotFound.bind(this),
+            error: this.handleError.bind(this),
+            routes: {
+                ...DefaultRoutes_1.DEFAULT_STATIC_ROUTES,
+                ...this.routes
+            }
+        };
+        this.server = Bun.serve(config);
+        // Execute BOOT hooks after server is ready
+        if (this.hasBootHooks) {
+            this.executeLifecycleHooks(Lifecycle_1.EventType.BOOT);
+        }
+        // Register shutdown handlers
+        if (this.hasShutdownHooks) {
+            this.registerShutdownHandlers();
+        }
+        if (!this.config.disableStartupLog) {
+            console.log(`Carno running on port ${port}`);
+        }
+    }
+    bootstrap() {
+        // Cache lifecycle event flags
+        this.hasInitHooks = (0, Lifecycle_1.hasEventHandlers)(Lifecycle_1.EventType.INIT);
+        this.hasBootHooks = (0, Lifecycle_1.hasEventHandlers)(Lifecycle_1.EventType.BOOT);
+        this.hasShutdownHooks = (0, Lifecycle_1.hasEventHandlers)(Lifecycle_1.EventType.SHUTDOWN);
+        // Register Container itself so it can be injected
+        this.container.register({
+            token: Container_1.Container,
+            useValue: this.container
+        });
+        // Always register CacheService (Memory by default)
+        const cacheConfig = typeof this.config.cache === 'object' ? this.config.cache : {};
+        this.container.register({
+            token: CacheService_1.CacheService,
+            useValue: new CacheService_1.CacheService(cacheConfig)
+        });
+        for (const service of this._services) {
+            this.container.register(service);
+        }
+        for (const ControllerClass of this._controllers) {
+            this.container.register(ControllerClass);
+        }
+        if (this.hasInitHooks) {
+            this.executeLifecycleHooks(Lifecycle_1.EventType.INIT);
+        }
+        for (const service of this._services) {
+            const token = typeof service === 'function' ? service : service.token;
+            const serviceConfig = typeof service === 'function' ? null : service;
+            if (!serviceConfig || serviceConfig.scope !== Container_1.Scope.REQUEST) {
+                this.container.get(token);
+            }
+        }
+    }
+    compileRoutes() {
+        for (const ControllerClass of this._controllers) {
+            this.compileController(ControllerClass);
+        }
+    }
+    compileController(ControllerClass, parentPath = '', inheritedMiddlewares = []) {
+        const meta = Reflect.getMetadata(metadata_1.CONTROLLER_META, ControllerClass) || { path: '' };
+        const basePath = parentPath + (meta.path || '');
+        const routes = Reflect.getMetadata(metadata_1.ROUTES_META, ControllerClass) || [];
+        const middlewares = Reflect.getMetadata(metadata_1.MIDDLEWARE_META, ControllerClass) || [];
+        const instance = this.container.get(ControllerClass);
+        // Extract controller-level middlewares (applied to all routes of this controller)
+        const controllerMiddlewares = middlewares
+            .filter(m => !m.target)
+            .map(m => m.handler);
+        // Combine inherited middlewares with this controller's middlewares
+        // This combined list is passed down to children and applied to current routes
+        const scopedMiddlewares = [...inheritedMiddlewares, ...controllerMiddlewares];
+        for (const route of routes) {
+            const fullPath = this.normalizePath(basePath + route.path);
+            const params = Reflect.getMetadata(metadata_1.PARAMS_META, ControllerClass, route.handlerName) || [];
+            // Middlewares specific to this route handler
+            const routeMiddlewares = middlewares
+                .filter(m => m.target === route.handlerName)
+                .map(m => m.handler);
+            // Get parameter types for validation
+            const paramTypes = Reflect.getMetadata('design:paramtypes', ControllerClass.prototype, route.handlerName) || [];
+            // Find Body param with DTO that has @Schema for validation
+            let bodyDtoType = null;
+            for (const param of params) {
+                if (param.type === 'body' && !param.key) {
+                    const dtoType = paramTypes[param.index];
+                    if (dtoType && this.validator?.hasValidation(dtoType)) {
+                        bodyDtoType = dtoType;
+                    }
+                }
+            }
+            const compiled = (0, JITCompiler_1.compileHandler)(instance, route.handlerName, params);
+            const allMiddlewares = [
+                ...(this.config.globalMiddlewares || []),
+                ...this._middlewares,
+                ...scopedMiddlewares,
+                ...routeMiddlewares
+            ];
+            // Pre-resolve class-based middlewares at compile time for maximum performance
+            const resolvedMiddlewares = allMiddlewares.map(m => this.resolveMiddleware(m));
+            const hasMiddlewares = resolvedMiddlewares.length > 0;
+            const method = route.method.toUpperCase();
+            // Static response - no function needed
+            if (compiled.isStatic && !hasMiddlewares) {
+                this.registerRoute(fullPath, method, this.createStaticResponse(compiled.staticValue));
+            }
+            else {
+                // Dynamic handler - compile to Bun-compatible function
+                this.registerRoute(fullPath, method, this.createHandler(compiled, params, resolvedMiddlewares, bodyDtoType));
+            }
+        }
+        // Compile child controllers with parent path and inherited middlewares
+        if (meta.children) {
+            for (const ChildController of meta.children) {
+                if (!this.container.has(ChildController)) {
+                    this.container.register(ChildController);
+                }
+                this.compileController(ChildController, basePath, scopedMiddlewares);
+            }
+        }
+    }
+    /**
+     * Register a route with Bun's native router format.
+     * Path: "/users/:id", Method: "GET", Handler: Function or Response
+     */
+    registerRoute(path, method, handler) {
+        if (!this.routes[path]) {
+            this.routes[path] = {};
+        }
+        this.routes[path][method] = handler;
+    }
+    createStaticResponse(value) {
+        const isString = typeof value === 'string';
+        const body = isString ? value : JSON.stringify(value);
+        const opts = isString ? TEXT_OPTS : JSON_OPTS;
+        return new Response(body, opts);
+    }
+    createHandler(compiled, params, middlewares, bodyDtoType) {
+        const handler = compiled.fn;
+        const hasMiddlewares = middlewares.length > 0;
+        const hasParams = params.length > 0;
+        const applyCors = this.hasCors ? this.applyCors.bind(this) : null;
+        const validator = bodyDtoType ? this.validator : null;
+        const needsValidation = !!validator;
+        // Force middleware path when validation is needed
+        const hasMiddlewaresOrValidation = hasMiddlewares || needsValidation;
+        // No middlewares, no params - fastest path
+        if (!hasMiddlewaresOrValidation && !hasParams) {
+            if (compiled.isAsync) {
+                return async (req) => {
+                    const ctx = new Context_1.Context(req);
+                    const result = await handler(ctx);
+                    const response = this.buildResponse(result);
+                    return applyCors ? applyCors(response, req) : response;
+                };
+            }
+            return (req) => {
+                const ctx = new Context_1.Context(req);
+                const result = handler(ctx);
+                const response = this.buildResponse(result);
+                return applyCors ? applyCors(response, req) : response;
+            };
+        }
+        // With params - use Bun's native req.params
+        if (!hasMiddlewaresOrValidation && hasParams) {
+            if (compiled.isAsync) {
+                return async (req) => {
+                    const ctx = new Context_1.Context(req, req.params);
+                    const result = await handler(ctx);
+                    const response = this.buildResponse(result);
+                    return applyCors ? applyCors(response, req) : response;
+                };
+            }
+            return (req) => {
+                const ctx = new Context_1.Context(req, req.params);
+                const result = handler(ctx);
+                const response = this.buildResponse(result);
+                return applyCors ? applyCors(response, req) : response;
+            };
+        }
+        // With middlewares - full pipeline
+        return async (req) => {
+            const ctx = new Context_1.Context(req, req.params || {});
+            for (const middleware of middlewares) {
+                const result = await middleware(ctx);
+                if (result instanceof Response) {
+                    return applyCors ? applyCors(result, req) : result;
+                }
+            }
+            // Validate body if validator is configured
+            if (validator && bodyDtoType) {
+                await ctx.parseBody();
+                validator.validateOrThrow(bodyDtoType, ctx.body);
+            }
+            const result = compiled.isAsync
+                ? await handler(ctx)
+                : handler(ctx);
+            const response = this.buildResponse(result);
+            return applyCors ? applyCors(response, req) : response;
+        };
+    }
+    resolveMiddleware(middleware) {
+        // Check if it's a class with a handle method
+        if (typeof middleware === 'function' && middleware.prototype?.handle) {
+            // Instantiate via Container and bind the handle method
+            const instance = this.container.get(middleware);
+            return (ctx) => instance.handle(ctx, () => { });
+        }
+        // Already a function
+        return middleware;
+    }
+    /**
+     * Apply CORS headers to a response.
+     */
+    applyCors(response, req) {
+        const origin = req.headers.get('origin');
+        if (origin && this.corsHandler) {
+            return this.corsHandler.apply(response, origin);
+        }
+        return response;
     }
-    return plugin._services.length > 0 && this._services.push(...plugin._services), plugin.config.globalMiddlewares && this._middlewares.push(...plugin.config.globalMiddlewares), plugin._middlewares.length > 0 && this._middlewares.push(...plugin._middlewares), this;
-  }
-  findServiceInPlugin(plugin, exported) {
-    return plugin._services.find(
-      (s) => this.getServiceToken(s) === this.getServiceToken(exported)
-    );
-  }
-  getServiceToken(service) {
-    return service?.token || service;
-  }
-  shouldCloneService(service) {
-    return !!(service?.useValue !== void 0 || service?.useClass);
-  }
-  /**
-   * Register one or more services/providers.
-   */
-  services(serviceClass) {
-    const items = Array.isArray(serviceClass) ? serviceClass : [serviceClass];
-    return this._services.push(...items), this;
-  }
-  /**
-   * Register one or more global middlewares.
-   */
-  middlewares(handler) {
-    const items = Array.isArray(handler) ? handler : [handler];
-    return this._middlewares.push(...items), this;
-  }
-  /**
-   * Register one or more controllers.
-   */
-  controllers(controllerClass) {
-    const items = Array.isArray(controllerClass) ? controllerClass : [controllerClass];
-    return this._controllers.push(...items), this;
-  }
-  /**
-   * Get a service instance from the container.
-   */
-  get(token) {
-    return this.container.get(token);
-  }
-  listen(port = 3e3) {
-    this.bootstrap(), this.compileRoutes();
-    const config = {
-      port,
-      fetch: this.handleNotFound.bind(this),
-      error: this.handleError.bind(this),
-      routes: {
-        ...import_DefaultRoutes.DEFAULT_STATIC_ROUTES,
-        ...this.routes
-      }
-    };
-    this.server = Bun.serve(config), this.hasBootHooks && this.executeLifecycleHooks(import_Lifecycle.EventType.BOOT), this.hasShutdownHooks && this.registerShutdownHandlers(), this.config.disableStartupLog || console.log(`Carno running on port ${port}`);
-  }
-  bootstrap() {
-    this.hasInitHooks = (0, import_Lifecycle.hasEventHandlers)(import_Lifecycle.EventType.INIT), this.hasBootHooks = (0, import_Lifecycle.hasEventHandlers)(import_Lifecycle.EventType.BOOT), this.hasShutdownHooks = (0, import_Lifecycle.hasEventHandlers)(import_Lifecycle.EventType.SHUTDOWN), this.container.register({
-      token: import_Container.Container,
-      useValue: this.container
-    });
-    const cacheConfig = typeof this.config.cache == "object" ? this.config.cache : {};
-    this.container.register({
-      token: import_CacheService.CacheService,
-      useValue: new import_CacheService.CacheService(cacheConfig)
-    });
-    for (const service of this._services)
-      this.container.register(service);
-    for (const ControllerClass of this._controllers)
-      this.container.register(ControllerClass);
-    this.hasInitHooks && this.executeLifecycleHooks(import_Lifecycle.EventType.INIT);
-    for (const service of this._services) {
-      const token = typeof service == "function" ? service : service.token, serviceConfig = typeof service == "function" ? null : service;
-      (!serviceConfig || serviceConfig.scope !== import_Container.Scope.REQUEST) && this.container.get(token);
+    /**
+     * Fallback handler - only called for unmatched routes.
+     * All matched routes go through Bun's native router.
+     */
+    handleNotFound(req) {
+        // CORS preflight for unmatched routes
+        if (this.hasCors && req.method === 'OPTIONS') {
+            const origin = req.headers.get('origin');
+            if (origin) {
+                return this.corsHandler.preflight(origin);
+            }
+        }
+        return NOT_FOUND_RESPONSE;
+    }
+    buildResponse(result) {
+        if (result instanceof Response) {
+            return result;
+        }
+        if (typeof result === 'string') {
+            return new Response(result, TEXT_OPTS);
+        }
+        // Handle undefined/void return values - return empty 204 No Content
+        if (result === undefined) {
+            return new Response(null, { status: 204 });
+        }
+        return Response.json(result);
+    }
+    normalizePath(path) {
+        if (!path.startsWith('/'))
+            path = '/' + path;
+        if (path !== '/' && path.endsWith('/'))
+            path = path.slice(0, -1);
+        return path.replace(/\/+/g, '/');
+    }
+    hasParams(path) {
+        return path.includes(':') || path.includes('*');
     }
-  }
-  compileRoutes() {
-    for (const ControllerClass of this._controllers)
-      this.compileController(ControllerClass);
-  }
-  compileController(ControllerClass, parentPath = "", inheritedMiddlewares = []) {
-    const meta = Reflect.getMetadata(import_metadata.CONTROLLER_META, ControllerClass) || { path: "" }, basePath = parentPath + (meta.path || ""), routes = Reflect.getMetadata(import_metadata.ROUTES_META, ControllerClass) || [], middlewares = Reflect.getMetadata(import_metadata.MIDDLEWARE_META, ControllerClass) || [], instance = this.container.get(ControllerClass), controllerMiddlewares = middlewares.filter((m) => !m.target).map((m) => m.handler), scopedMiddlewares = [...inheritedMiddlewares, ...controllerMiddlewares];
-    for (const route of routes) {
-      const fullPath = this.normalizePath(basePath + route.path), params = Reflect.getMetadata(import_metadata.PARAMS_META, ControllerClass, route.handlerName) || [], routeMiddlewares = middlewares.filter((m) => m.target === route.handlerName).map((m) => m.handler), paramTypes = Reflect.getMetadata("design:paramtypes", ControllerClass.prototype, route.handlerName) || [];
-      let bodyDtoType = null;
-      for (const param of params)
-        if (param.type === "body" && !param.key) {
-          const dtoType = paramTypes[param.index];
-          dtoType && this.validator?.hasValidation(dtoType) && (bodyDtoType = dtoType);
-        }
-      const compiled = (0, import_JITCompiler.compileHandler)(instance, route.handlerName, params), resolvedMiddlewares = [
-        ...this.config.globalMiddlewares || [],
-        ...this._middlewares,
-        ...scopedMiddlewares,
-        ...routeMiddlewares
-      ].map((m) => this.resolveMiddleware(m)), hasMiddlewares = resolvedMiddlewares.length > 0, method = route.method.toUpperCase();
-      compiled.isStatic && !hasMiddlewares ? this.registerRoute(fullPath, method, this.createStaticResponse(compiled.staticValue)) : this.registerRoute(fullPath, method, this.createHandler(compiled, params, resolvedMiddlewares, bodyDtoType));
+    stop() {
+        this.server?.stop?.();
     }
-    if (meta.children)
-      for (const ChildController of meta.children)
-        this.container.has(ChildController) || this.container.register(ChildController), this.compileController(ChildController, basePath, scopedMiddlewares);
-  }
-  /**
-   * Register a route with Bun's native router format.
-   * Path: "/users/:id", Method: "GET", Handler: Function or Response
-   */
-  registerRoute(path, method, handler) {
-    this.routes[path] || (this.routes[path] = {}), this.routes[path][method] = handler;
-  }
-  createStaticResponse(value) {
-    const isString = typeof value == "string", body = isString ? value : JSON.stringify(value), opts = isString ? TEXT_OPTS : JSON_OPTS;
-    return new Response(body, opts);
-  }
-  createHandler(compiled, params, middlewares, bodyDtoType) {
-    const handler = compiled.fn, hasMiddlewares = middlewares.length > 0, hasParams = params.length > 0, applyCors = this.hasCors ? this.applyCors.bind(this) : null, validator = bodyDtoType ? this.validator : null, hasMiddlewaresOrValidation = hasMiddlewares || !!validator;
-    return !hasMiddlewaresOrValidation && !hasParams ? compiled.isAsync ? async (req) => {
-      const ctx = new import_Context.Context(req), result = await handler(ctx), response = this.buildResponse(result);
-      return applyCors ? applyCors(response, req) : response;
-    } : (req) => {
-      const ctx = new import_Context.Context(req), result = handler(ctx), response = this.buildResponse(result);
-      return applyCors ? applyCors(response, req) : response;
-    } : !hasMiddlewaresOrValidation && hasParams ? compiled.isAsync ? async (req) => {
-      const ctx = new import_Context.Context(req, req.params), result = await handler(ctx), response = this.buildResponse(result);
-      return applyCors ? applyCors(response, req) : response;
-    } : (req) => {
-      const ctx = new import_Context.Context(req, req.params), result = handler(ctx), response = this.buildResponse(result);
-      return applyCors ? applyCors(response, req) : response;
-    } : async (req) => {
-      const ctx = new import_Context.Context(req, req.params || {});
-      for (const middleware of middlewares) {
-        const result2 = await middleware(ctx);
-        if (result2 instanceof Response)
-          return applyCors ? applyCors(result2, req) : result2;
-      }
-      validator && bodyDtoType && (await ctx.parseBody(), validator.validateOrThrow(bodyDtoType, ctx.body));
-      const result = compiled.isAsync ? await handler(ctx) : handler(ctx), response = this.buildResponse(result);
-      return applyCors ? applyCors(response, req) : response;
-    };
-  }
-  resolveMiddleware(middleware) {
-    if (typeof middleware == "function" && middleware.prototype?.handle) {
-      const instance = this.container.get(middleware);
-      return (ctx) => instance.handle(ctx, () => {
-      });
+    /**
+     * Error handler for Bun.serve.
+     * Converts exceptions to proper HTTP responses.
+     */
+    handleError(error) {
+        let response;
+        // HttpException - return custom response
+        if (error instanceof HttpException_1.HttpException) {
+            response = error.toResponse();
+        }
+        // ValidationException - return 400 with errors
+        else if (error instanceof ZodAdapter_1.ValidationException) {
+            response = error.toResponse();
+        }
+        // Unknown error - return 500
+        else {
+            console.error('Unhandled error:', error);
+            response = INTERNAL_ERROR_RESPONSE;
+        }
+        // Apply CORS headers if configured
+        if (this.hasCors && this.corsHandler) {
+            return this.corsHandler.apply(response, '*');
+        }
+        return response;
     }
-    return middleware;
-  }
-  /**
-   * Apply CORS headers to a response.
-   */
-  applyCors(response, req) {
-    const origin = req.headers.get("origin");
-    return origin && this.corsHandler ? this.corsHandler.apply(response, origin) : response;
-  }
-  /**
-   * Fallback handler - only called for unmatched routes.
-   * All matched routes go through Bun's native router.
-   */
-  handleNotFound(req) {
-    if (this.hasCors && req.method === "OPTIONS") {
-      const origin = req.headers.get("origin");
-      if (origin)
-        return this.corsHandler.preflight(origin);
+    /**
+     * Execute lifecycle hooks for a specific event type.
+     */
+    executeLifecycleHooks(type) {
+        const handlers = (0, Lifecycle_1.getEventHandlers)(type);
+        for (const handler of handlers) {
+            try {
+                const instance = this.container.has(handler.target)
+                    ? this.container.get(handler.target)
+                    : null;
+                if (instance && typeof instance[handler.methodName] === 'function') {
+                    const result = instance[handler.methodName]();
+                    // Handle async hooks
+                    if (result instanceof Promise) {
+                        result.catch((err) => console.error(`Error in ${type} hook ${handler.methodName}:`, err));
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`Error in ${type} hook ${handler.methodName}:`, err);
+            }
+        }
+    }
+    /**
+     * Register SIGTERM/SIGINT handlers for graceful shutdown.
+     */
+    registerShutdownHandlers() {
+        const shutdown = () => {
+            this.executeLifecycleHooks(Lifecycle_1.EventType.SHUTDOWN);
+            this.stop();
+            process.exit(0);
+        };
+        process.on('SIGTERM', shutdown);
+        process.on('SIGINT', shutdown);
     }
-    return NOT_FOUND_RESPONSE;
-  }
-  buildResponse(result) {
-    return result instanceof Response ? result : typeof result == "string" ? new Response(result, TEXT_OPTS) : result === void 0 ? new Response(null, { status: 204 }) : Response.json(result);
-  }
-  normalizePath(path) {
-    return path.startsWith("/") || (path = "/" + path), path !== "/" && path.endsWith("/") && (path = path.slice(0, -1)), path.replace(/\/+/g, "/");
-  }
-  hasParams(path) {
-    return path.includes(":") || path.includes("*");
-  }
-  stop() {
-    this.server?.stop?.();
-  }
-  /**
-   * Error handler for Bun.serve.
-   * Converts exceptions to proper HTTP responses.
-   */
-  handleError(error) {
-    let response;
-    return error instanceof import_HttpException.HttpException || error instanceof import_ZodAdapter.ValidationException ? response = error.toResponse() : (console.error("Unhandled error:", error), response = INTERNAL_ERROR_RESPONSE), this.hasCors && this.corsHandler ? this.corsHandler.apply(response, "*") : response;
-  }
-  /**
-   * Execute lifecycle hooks for a specific event type.
-   */
-  executeLifecycleHooks(type) {
-    const handlers = (0, import_Lifecycle.getEventHandlers)(type);
-    for (const handler of handlers)
-      try {
-        const instance = this.container.has(handler.target) ? this.container.get(handler.target) : null;
-        if (instance && typeof instance[handler.methodName] == "function") {
-          const result = instance[handler.methodName]();
-          result instanceof Promise && result.catch(
-            (err) => console.error(`Error in ${type} hook ${handler.methodName}:`, err)
-          );
-        }
-      } catch (err) {
-        console.error(`Error in ${type} hook ${handler.methodName}:`, err);
-      }
-  }
-  /**
-   * Register SIGTERM/SIGINT handlers for graceful shutdown.
-   */
-  registerShutdownHandlers() {
-    const shutdown = () => {
-      this.executeLifecycleHooks(import_Lifecycle.EventType.SHUTDOWN), this.stop(), process.exit(0);
-    };
-    process.on("SIGTERM", shutdown), process.on("SIGINT", shutdown);
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Carno
-});
+exports.Carno = Carno;