@carno.js/core 0.2.11 → 1.0.2

package/dist/Carno.js

@@ -1,338 +1,277 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Carno = void 0;
-const node_process_1 = __importDefault(require("node:process"));
-const ZodAdapter_1 = require("./validation/adapters/ZodAdapter");
-const ValidationCache_1 = require("./utils/ValidationCache");
-const index_1 = require("./commons/index");
-const constants_1 = require("./constants");
-const createContainer_1 = require("./container/createContainer");
-const createInjector_1 = require("./container/createInjector");
-const domain_1 = require("./domain");
-const Context_1 = require("./domain/Context");
-const LocalsContainer_1 = require("./domain/LocalsContainer");
-const cors_headers_cache_1 = require("./domain/cors-headers-cache");
-const on_event_1 = require("./events/on-event");
-const HttpException_1 = require("./exceptions/HttpException");
-const RouteExecutor_1 = require("./route/RouteExecutor");
-const memoirist_1 = __importDefault(require("./route/memoirist"));
-const CompiledRoute_1 = require("./route/CompiledRoute");
-const logger_service_1 = require("./services/logger.service");
-const METHOD_MAP = {
-    GET: 'get',
-    POST: 'post',
-    PUT: 'put',
-    DELETE: 'delete',
-    PATCH: 'patch',
-    HEAD: 'head',
-    OPTIONS: 'options'
+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
+});
+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.router = new memoirist_1.default();
-        this.injector = (0, createInjector_1.createInjector)();
-        this.emptyLocals = new LocalsContainer_1.LocalsContainer();
-        this.corsEnabled = false;
-        this.hasOnRequestHook = false;
-        this.fetch = (request, server) => {
-            const method = request.method;
-            if (this.corsEnabled) {
-                const origin = request.headers.get("origin");
-                if (method === "OPTIONS" && origin) {
-                    return this.handlePreflightRequest(request);
-                }
-            }
-            const url = request.url;
-            const startIndex = url.indexOf('/', 12);
-            const queryIndex = url.indexOf('?', startIndex);
-            const pathname = queryIndex === -1
-                ? (startIndex === -1 ? '/' : url.slice(startIndex))
-                : url.slice(startIndex, queryIndex);
-            const methodLower = METHOD_MAP[method] || method.toLowerCase();
-            const route = this.router.find(methodLower, pathname);
-            if (!route) {
-                return this.errorResponse(request, "Method not allowed", 404);
-            }
-            const compiled = route.store;
-            const isCompiledRoute = compiled.routeType !== undefined;
-            const isSimpleRoute = isCompiledRoute && compiled.routeType === CompiledRoute_1.RouteType.SIMPLE;
-            const isGetOrHead = method === 'GET' || method === 'HEAD';
-            const hasQuery = queryIndex !== -1;
-            if (isSimpleRoute && isGetOrHead && !this.corsEnabled && !hasQuery && !compiled.isAsync) {
-                const context = Context_1.Context.createFastContext(request, route.params);
-                return compiled.boundHandler(context);
-            }
-            return this.fetcherAsync(request, server, route, compiled, isSimpleRoute, hasQuery, queryIndex, url);
-        };
-        this.catcher = (error) => {
-            this.resolveLogger().error("Unhandled error", error);
-            return new Response("Internal Server Error", { status: 500 });
-        };
-        this.validatorAdapter = this.resolveValidatorAdapter();
-        if (config.cors) {
-            this.corsCache = new cors_headers_cache_1.CorsHeadersCache(config.cors);
-        }
-        void this.bootstrapApplication();
-    }
-    resolveValidatorAdapter() {
-        const config = this.config.validation;
-        if (!config?.adapter) {
-            return new ZodAdapter_1.ZodAdapter();
-        }
-        const AdapterClass = config.adapter;
-        const options = config.options || {};
-        return new AdapterClass(options);
-    }
-    /**
-     * Use the Carno plugin.
-     *
-     * @param plugin
-     */
-    use(plugin) {
-        if (!this.config.providers) {
-            this.config.providers = [];
-        }
-        if (!this.config.globalMiddlewares) {
-            this.config.globalMiddlewares = [];
-        }
-        for (const exportProvider of plugin.config.exports || []) {
-            const existingProvider = this.findProviderInConfig(plugin, exportProvider);
-            const providerToAdd = this.shouldCloneProvider(existingProvider)
-                ? this.cloneProvider(existingProvider)
-                : exportProvider;
-            this.config.providers.push(providerToAdd);
-        }
-        if (plugin.config.globalMiddlewares) {
-            this.config.globalMiddlewares.push(...plugin.config.globalMiddlewares);
-        }
-        return this;
-    }
-    findProviderInConfig(plugin, exportProvider) {
-        return plugin.config.providers?.find((p) => this.getProviderToken(p) === this.getProviderToken(exportProvider));
-    }
-    getProviderToken(provider) {
-        return provider?.provide || provider;
-    }
-    shouldCloneProvider(provider) {
-        return !!(provider?.useValue !== undefined || provider?.useClass);
-    }
-    cloneProvider(provider) {
-        return { ...provider };
-    }
-    /**
-     * Set the custom logger provider.
-     * The provider must be a class with the @Service() decorator.
-     * The provider must extend the LoggerService class.
-     *
-     * @param provider
-     */
-    useLogger(provider) {
-        (0, index_1.registerProvider)({ provide: logger_service_1.LoggerService, useClass: provider });
-        return this;
-    }
-    loadProvidersAndControllers() {
-        const providers = domain_1.Metadata.get(constants_1.PROVIDER, Reflect) || [];
-        const controllers = domain_1.Metadata.get(constants_1.CONTROLLER, Reflect) || [];
-        this.registerControllers(controllers);
-        this.registerMetadataProviders(providers);
-        this.registerConfigProviders();
-    }
-    registerControllers(controllers) {
-        for (const controller of controllers) {
-            (0, index_1.registerController)(controller);
-            controller.options?.children &&
-                controller.options.children.forEach((child) => {
-                    (0, index_1.registerController)({ provide: child, parent: controller.provide });
-                });
-        }
-    }
-    registerMetadataProviders(providers) {
-        for (const provider of providers) {
-            (0, index_1.registerProvider)(provider);
-        }
-    }
-    registerConfigProviders() {
-        if (!this.config.providers) {
-            return;
-        }
-        for (const provider of this.config.providers) {
-            const normalized = this.normalizeProvider(provider);
-            (0, index_1.registerProvider)(normalized);
-        }
-    }
-    normalizeProvider(provider) {
-        if (provider?.provide) {
-            return provider;
-        }
-        return {
-            provide: provider,
-            useClass: provider,
-        };
-    }
-    async init() {
-        (0, ValidationCache_1.setValidatorAdapter)(this.validatorAdapter);
-        this.loadProvidersAndControllers();
-        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router, this.validatorAdapter);
-        this.corsEnabled = !!this.config.cors;
-        this.hasOnRequestHook = this.injector.hasOnRequestHook();
-    }
-    async listen(port = 3000) {
-        this.registerShutdownHandlers();
-        await this.init();
-        this.createHttpServer(port);
-    }
-    registerShutdownHandlers() {
-        const shutdown = async (signal) => {
-            this.resolveLogger().info(`Received ${signal}, starting graceful shutdown...`);
-            await this.handleShutdownHook();
-        };
-        node_process_1.default.on("SIGTERM", () => shutdown("SIGTERM"));
-        node_process_1.default.on("SIGINT", () => shutdown("SIGINT"));
-    }
-    getHttpServer() {
-        return this.server;
-    }
-    getInjector() {
-        return this.injector;
-    }
-    createHttpServer(port) {
-        this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
-        if (!this.config.disableStartupLog) {
-            this.resolveLogger().info(`Server running on port ${port}`);
-        }
-    }
-    async fetcherAsync(request, server, route, compiled, isSimpleRoute, hasQuery, queryIndex, url) {
-        try {
-            let response;
-            const query = hasQuery ? url.slice(queryIndex + 1) : undefined;
-            const context = Context_1.Context.createFromRequestSync({ query }, request, server);
-            context.param = route.params;
-            if (isSimpleRoute) {
-                response = compiled.isAsync
-                    ? await compiled.boundHandler(context)
-                    : compiled.boundHandler(context);
-            }
-            else {
-                const needsLocalsContainer = compiled.routeType !== undefined
-                    ? compiled.needsLocalsContainer
-                    : true;
-                const locals = this.resolveLocalsContainer(needsLocalsContainer, context);
-                if (this.hasOnRequestHook) {
-                    await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
-                }
-                response = await RouteExecutor_1.RouteExecutor.executeRoute(compiled, this.injector, context, locals);
-            }
-            if (this.corsEnabled) {
-                const origin = request.headers.get("origin");
-                if (origin && this.corsCache.isOriginAllowed(origin)) {
-                    if (!(response instanceof Response)) {
-                        response = RouteExecutor_1.RouteExecutor.mountResponse(response, context);
-                    }
-                    return this.applyCorsHeaders(response, origin);
-                }
-            }
-            return response;
-        }
-        catch (error) {
-            if (error instanceof HttpException_1.HttpException) {
-                return this.errorResponse(request, error.getResponse(), error.getStatus());
-            }
-            throw error;
-        }
-    }
-    async bootstrapApplication() {
-        try {
-            await this.injector.callHook(on_event_1.EventType.OnApplicationBoot, {});
-        }
-        catch (error) {
-            this.reportHookFailure(on_event_1.EventType.OnApplicationBoot, error);
-        }
-    }
-    async handleShutdownHook() {
-        try {
-            await this.injector.callHook(on_event_1.EventType.OnApplicationShutdown);
-            this.closeHttpServer();
-            this.exitProcess();
-        }
-        catch (error) {
-            this.reportHookFailure(on_event_1.EventType.OnApplicationShutdown, error);
-            this.exitProcess(1);
-        }
-    }
-    closeHttpServer() {
-        if (this.server) {
-            this.resolveLogger().info("Closing HTTP server...");
-            this.server.stop(true);
-        }
-    }
-    exitProcess(code = 0) {
-        this.resolveLogger().info("Shutdown complete.");
-        node_process_1.default.exit(code);
-    }
-    reportHookFailure(event, error) {
-        this.resolveLogger().error(`Lifecycle hook ${event} failed`, error);
-    }
-    resolveLogger() {
-        const provider = this.injector.get(logger_service_1.LoggerService);
-        const instance = provider?.instance;
-        return instance ?? new logger_service_1.LoggerService(this.injector);
-    }
-    isCorsEnabled() {
-        return !!this.config.cors;
-    }
-    errorResponse(request, message, statusCode) {
-        let response = new Response(JSON.stringify({
-            message,
-            statusCode,
-        }), {
-            status: statusCode,
-            headers: { "Content-Type": "application/json" },
-        });
-        if (this.corsEnabled) {
-            const origin = request.headers.get("origin");
-            if (origin && this.corsCache.isOriginAllowed(origin)) {
-                response = this.applyCorsHeaders(response, origin);
-            }
-        }
-        return response;
-    }
-    handlePreflightRequest(request) {
-        const origin = request.headers.get("origin");
-        if (!origin || !this.corsCache.isOriginAllowed(origin)) {
-            return new Response(null, { status: 403 });
+  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);
+    }
+    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);
+    }
+  }
+  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 corsHeaders = this.corsCache.get(origin);
-        return new Response(null, {
-            status: 204,
-            headers: corsHeaders,
-        });
-    }
-    applyCorsHeaders(response, origin) {
-        return this.corsCache.applyToResponse(response, origin);
-    }
-    close(closeActiveConnections = false) {
-        this.server?.stop(closeActiveConnections);
-    }
-    resolveLocalsContainer(needsLocalsContainer, context) {
-        if (!needsLocalsContainer) {
-            return this.emptyLocals;
+      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));
+    }
+    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, () => {
+      });
+    }
+    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)
+          );
         }
-        return this.buildLocalsContainer(context);
-    }
-    buildLocalsContainer(context) {
-        const locals = new LocalsContainer_1.LocalsContainer();
-        locals.set(Context_1.Context, context);
-        return locals;
-    }
-    discoverRoutePath(url) {
-        if (typeof url === 'string') {
-            return url;
-        }
-        return url?.pathname || url?.path || '/';
-    }
+      } 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
+});