@carno.js/core 1.0.3 → 1.0.4

package/dist/Carno.js

@@ -1,474 +1,277 @@
-"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' }
+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
 });
-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
- */
+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" } }
+);
 class Carno {
-    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;
+  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);
     }
-    /**
-     * 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('*');
+    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);
     }
-    stop() {
-        this.server?.stop?.();
+  }
+  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));
     }
-    /**
-     * 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;
+    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, () => {
+      });
     }
-    /**
-     * 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 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);
     }
+    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);
+  }
 }
-exports.Carno = Carno;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Carno
+});