@riktajs/core 0.10.2 → 0.10.3

package/dist/index.cjs

@@ -0,0 +1,3591 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUTOWIRED_METADATA: () => AUTOWIRED_METADATA,
+  AbstractClass: () => AbstractClass,
+  AbstractConfigProvider: () => AbstractConfigProvider,
+  Autowired: () => Autowired,
+  BadGatewayException: () => BadGatewayException,
+  BadRequestException: () => BadRequestException,
+  Body: () => Body,
+  CATCH_METADATA: () => CATCH_METADATA,
+  CONFIG_PROPERTY_METADATA: () => CONFIG_PROPERTY_METADATA,
+  CONFIG_PROVIDER_METADATA: () => CONFIG_PROVIDER_METADATA,
+  CONTROLLER_METADATA: () => CONTROLLER_METADATA,
+  CUSTOM_PARAM_METADATA: () => CUSTOM_PARAM_METADATA,
+  Catch: () => Catch,
+  ConfigProperty: () => ConfigProperty,
+  ConfigProviderAlreadyRegisteredException: () => ConfigProviderAlreadyRegisteredException,
+  ConfigProviderInstantiationException: () => ConfigProviderInstantiationException,
+  ConfigProviderNotFoundException: () => ConfigProviderNotFoundException,
+  ConfigValidationException: () => ConfigValidationException,
+  ConflictException: () => ConflictException,
+  Container: () => Container,
+  Context: () => Context,
+  Controller: () => Controller,
+  Ctx: () => Ctx,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  Delete: () => Delete,
+  DiscoveryException: () => DiscoveryException,
+  EventBus: () => EventBus,
+  ExecutionContextImpl: () => ExecutionContextImpl,
+  ForbiddenException: () => ForbiddenException,
+  GUARDS_METADATA: () => GUARDS_METADATA,
+  GatewayTimeoutException: () => GatewayTimeoutException,
+  Get: () => Get,
+  GlobalExceptionFilter: () => GlobalExceptionFilter,
+  GoneException: () => GoneException,
+  HEADERS_METADATA: () => HEADERS_METADATA,
+  HTTP_CODE_METADATA: () => HTTP_CODE_METADATA,
+  Head: () => Head,
+  Headers: () => Headers,
+  HttpCode: () => HttpCode,
+  HttpException: () => HttpException,
+  IMPLEMENTS_METADATA: () => IMPLEMENTS_METADATA,
+  INJECTABLE_METADATA: () => INJECTABLE_METADATA,
+  INJECT_METADATA: () => INJECT_METADATA,
+  INTERCEPTORS_METADATA: () => INTERCEPTORS_METADATA,
+  Implements: () => Implements,
+  Injectable: () => Injectable,
+  InjectionToken: () => InjectionToken,
+  InternalServerErrorException: () => InternalServerErrorException,
+  MIDDLEWARE_METADATA: () => MIDDLEWARE_METADATA,
+  MethodNotAllowedException: () => MethodNotAllowedException,
+  Middleware: () => Middleware,
+  Named: () => Named,
+  NotAcceptableException: () => NotAcceptableException,
+  NotFoundException: () => NotFoundException,
+  NotImplementedException: () => NotImplementedException,
+  ON_EVENT_METADATA: () => ON_EVENT_METADATA,
+  On: () => On,
+  Optional: () => Optional,
+  Options: () => Options,
+  PARAM_METADATA: () => PARAM_METADATA,
+  PRIMARY_METADATA: () => PRIMARY_METADATA,
+  PROVIDER_METADATA: () => PROVIDER_METADATA,
+  Param: () => Param,
+  ParamType: () => ParamType,
+  Patch: () => Patch,
+  PayloadTooLargeException: () => PayloadTooLargeException,
+  PerformanceProfiler: () => PerformanceProfiler,
+  Post: () => Post,
+  Primary: () => Primary,
+  Provider: () => Provider,
+  Put: () => Put,
+  Query: () => Query,
+  ROUTES_METADATA: () => ROUTES_METADATA,
+  Registry: () => Registry,
+  Reply: () => Reply,
+  Req: () => Req,
+  Request: () => Request,
+  RequestScopeStorage: () => RequestScopeStorage,
+  RequestTimeoutException: () => RequestTimeoutException,
+  Res: () => Res,
+  Rikta: () => RiktaFactory,
+  RiktaFactory: () => RiktaFactory,
+  Router: () => Router,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  SetMetadata: () => SetMetadata,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UnauthorizedException: () => UnauthorizedException,
+  UnprocessableEntityException: () => UnprocessableEntityException,
+  UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
+  UseGuards: () => UseGuards,
+  UseInterceptors: () => UseInterceptors,
+  UseMiddleware: () => UseMiddleware,
+  ValidationException: () => ValidationException,
+  ZOD_SCHEMA_METADATA: () => ZOD_SCHEMA_METADATA,
+  applyDecorators: () => applyDecorators,
+  clearPropertyNameCache: () => clearPropertyNameCache,
+  container: () => container,
+  createExceptionHandler: () => createExceptionHandler,
+  createParamDecorator: () => createParamDecorator,
+  default: () => RiktaFactory,
+  discoverModules: () => discoverModules,
+  extendsFrom: () => extendsFrom,
+  getCallerDirectory: () => getCallerDirectory,
+  getCatchMetadata: () => getCatchMetadata,
+  getClassMetadata: () => getClassMetadata,
+  getConfigPropertyMappings: () => getConfigPropertyMappings,
+  getConfigProviderMetadata: () => getConfigProviderMetadata,
+  getControllerMetadata: () => getControllerMetadata,
+  getControllerPath: () => getControllerPath,
+  getCustomParamMetadata: () => getCustomParamMetadata,
+  getGlobalProfiler: () => getGlobalProfiler,
+  getGuards: () => getGuards,
+  getGuardsMetadata: () => getGuardsMetadata,
+  getHttpCode: () => getHttpCode,
+  getImplementedAbstract: () => getImplementedAbstract,
+  getInterceptorsMetadata: () => getInterceptorsMetadata,
+  getMethodMetadata: () => getMethodMetadata,
+  getMethodsWithMetadata: () => getMethodsWithMetadata,
+  getMiddlewareMetadata: () => getMiddlewareMetadata,
+  getMiddlewaresMetadata: () => getMiddlewareMetadata,
+  getParamMetadata: () => getParamMetadata,
+  getParamMetadataByIndex: () => getParamMetadataByIndex,
+  getRoutes: () => getRoutes,
+  getZodSchema: () => getZodSchema,
+  hasClassMetadata: () => hasClassMetadata,
+  hasConfigProperties: () => hasConfigProperties,
+  hasMethodMetadata: () => hasMethodMetadata,
+  hasRoutes: () => hasRoutes,
+  isAbstractClass: () => isAbstractClass,
+  isConfigProvider: () => isConfigProvider,
+  isController: () => isController,
+  isEnvLoaded: () => isEnvLoaded,
+  isPrimaryImplementation: () => isPrimaryImplementation,
+  loadEnvFiles: () => loadEnvFiles,
+  markAsAbstract: () => markAsAbstract,
+  profiler: () => profiler,
+  registry: () => registry,
+  requestScopeStorage: () => requestScopeStorage,
+  resetEnvLoaded: () => resetEnvLoaded,
+  setGlobalProfiler: () => setGlobalProfiler,
+  setImplementsMetadata: () => setImplementsMetadata,
+  setPrimaryMetadata: () => setPrimaryMetadata,
+  z: () => import_zod2.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/constants.ts
+var CONTROLLER_METADATA = /* @__PURE__ */ Symbol.for("rikta:controller:metadata");
+var ROUTES_METADATA = /* @__PURE__ */ Symbol.for("rikta:routes:metadata");
+var INJECTABLE_METADATA = /* @__PURE__ */ Symbol.for("rikta:injectable:metadata");
+var PARAM_METADATA = /* @__PURE__ */ Symbol.for("rikta:param:metadata");
+var GUARDS_METADATA = /* @__PURE__ */ Symbol.for("rikta:guards:metadata");
+var INTERCEPTORS_METADATA = /* @__PURE__ */ Symbol.for("rikta:interceptors:metadata");
+var MIDDLEWARE_METADATA = /* @__PURE__ */ Symbol.for("rikta:middleware:metadata");
+var HTTP_CODE_METADATA = /* @__PURE__ */ Symbol.for("rikta:http:code:metadata");
+var HEADERS_METADATA = /* @__PURE__ */ Symbol.for("rikta:headers:metadata");
+var INJECT_METADATA = /* @__PURE__ */ Symbol.for("rikta:inject:metadata");
+var ZOD_SCHEMA_METADATA = /* @__PURE__ */ Symbol.for("rikta:zod:schema:metadata");
+var AUTOWIRED_METADATA = /* @__PURE__ */ Symbol.for("rikta:autowired:metadata");
+var PROVIDER_METADATA = /* @__PURE__ */ Symbol.for("rikta:provider:metadata");
+var CONFIG_PROVIDER_METADATA = /* @__PURE__ */ Symbol("config:provider:metadata");
+var CONFIG_PROPERTY_METADATA = /* @__PURE__ */ Symbol("config:property:metadata");
+var ParamType = /* @__PURE__ */ (function(ParamType2) {
+  ParamType2["BODY"] = "body";
+  ParamType2["QUERY"] = "query";
+  ParamType2["PARAM"] = "param";
+  ParamType2["HEADERS"] = "headers";
+  ParamType2["REQUEST"] = "request";
+  ParamType2["REPLY"] = "reply";
+  ParamType2["CONTEXT"] = "context";
+  return ParamType2;
+})({});
+var DEFAULT_CONFIG = {
+  port: 3e3,
+  host: "0.0.0.0",
+  logger: true,
+  prefix: ""
+};
+
+// src/core/container/container.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/core/container/injection-token.ts
+var InjectionToken = class {
+  static {
+    __name(this, "InjectionToken");
+  }
+  description;
+  options;
+  constructor(description, options) {
+    this.description = description;
+    this.options = options;
+  }
+  toString() {
+    return `InjectionToken(${this.description})`;
+  }
+};
+
+// src/core/exceptions/config.exceptions.ts
+var ConfigProviderAlreadyRegisteredException = class extends Error {
+  static {
+    __name(this, "ConfigProviderAlreadyRegisteredException");
+  }
+  constructor(token, existingClass, newClass) {
+    super(`Config provider with token "${token}" is already registered.
+Existing: ${existingClass}
+Attempted: ${newClass}
+Use a different token or remove the duplicate registration.`);
+    this.name = "ConfigProviderAlreadyRegisteredException";
+  }
+};
+var ConfigProviderNotFoundException = class extends Error {
+  static {
+    __name(this, "ConfigProviderNotFoundException");
+  }
+  constructor(token, availableTokens = []) {
+    const suggestion = availableTokens.length > 0 ? `
+
+Available tokens: ${availableTokens.join(", ")}` : "";
+    super(`Config provider with token "${token}" not found.${suggestion}
+Make sure the provider class is:
+1. Decorated with @Provider('${token}')
+2. Located in a file matching the autowired patterns
+3. Properly exported from its module`);
+    this.name = "ConfigProviderNotFoundException";
+  }
+};
+var ConfigProviderInstantiationException = class extends Error {
+  static {
+    __name(this, "ConfigProviderInstantiationException");
+  }
+  constructor(token, className, cause) {
+    super(`Failed to instantiate config provider "${className}" (token: "${token}").
+Cause: ${cause.message}
+
+Check that the provider:
+1. Has a valid constructor
+2. All constructor dependencies are registered
+3. The provide() method is correctly implemented`);
+    this.name = "ConfigProviderInstantiationException";
+    this.cause = cause;
+  }
+};
+
+// src/core/registry.ts
+var Registry = class Registry2 {
+  static {
+    __name(this, "Registry");
+  }
+  static instance;
+  /** All registered controllers */
+  controllers = /* @__PURE__ */ new Set();
+  /** All registered providers (services via @Injectable) */
+  providers = /* @__PURE__ */ new Set();
+  /** All registered custom providers (via @Provider) */
+  customProviders = /* @__PURE__ */ new Set();
+  /** Map of config provider tokens to their class constructors */
+  configProviderMap = /* @__PURE__ */ new Map();
+  /** Map of abstract classes to their implementations */
+  abstractImplementations = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!Registry2.instance) {
+      Registry2.instance = new Registry2();
+    }
+    return Registry2.instance;
+  }
+  /**
+  * Reset the registry (useful for testing)
+  */
+  static reset() {
+    const newInstance = new Registry2();
+    Registry2.instance = newInstance;
+  }
+  /**
+  * Register a controller
+  */
+  registerController(target) {
+    this.controllers.add(target);
+  }
+  /**
+  * Register a provider
+  */
+  registerProvider(target) {
+    this.providers.add(target);
+  }
+  /**
+  * Get all registered controllers
+  */
+  getControllers() {
+    return [
+      ...this.controllers
+    ];
+  }
+  /**
+  * Get all registered providers
+  */
+  getProviders() {
+    return [
+      ...this.providers
+    ];
+  }
+  /**
+  * Check if a controller is registered
+  */
+  hasController(target) {
+    return this.controllers.has(target);
+  }
+  /**
+  * Check if a provider is registered
+  */
+  hasProvider(target) {
+    return this.providers.has(target);
+  }
+  /**
+  * Register a custom provider (@Provider)
+  */
+  registerCustomProvider(target) {
+    this.customProviders.add(target);
+  }
+  /**
+  * Get all registered custom providers
+  */
+  getCustomProviders() {
+    return [
+      ...this.customProviders
+    ];
+  }
+  /**
+  * Check if a custom provider is registered
+  */
+  hasCustomProvider(target) {
+    return this.customProviders.has(target);
+  }
+  // ============================================================================
+  // Config Provider Methods
+  // ============================================================================
+  /**
+  * Register a config provider with its injection token
+  * 
+  * @param token - The injection token (e.g., 'APP_CONFIG')
+  * @param providerClass - The config provider class constructor
+  * @throws {ConfigProviderAlreadyRegisteredException} If the token is already registered
+  * 
+  * @example
+  * ```typescript
+  * registry.registerConfigProvider('APP_CONFIG', AppConfigProvider);
+  * ```
+  */
+  registerConfigProvider(token, providerClass) {
+    if (this.configProviderMap.has(token)) {
+      const existingClass = this.configProviderMap.get(token);
+      throw new ConfigProviderAlreadyRegisteredException(token, existingClass.name, providerClass.name);
+    }
+    this.configProviderMap.set(token, providerClass);
+  }
+  /**
+  * Get all registered config provider classes with their tokens
+  * 
+  * @returns Array of registration info objects
+  * 
+  * @internal Used by auto-discovery mechanism
+  */
+  getConfigProviderRegistrations() {
+    return Array.from(this.configProviderMap.entries()).map(([token, providerClass]) => ({
+      token,
+      providerClass
+    }));
+  }
+  /**
+  * Clear all config provider registrations (useful for testing)
+  * 
+  * This will remove all registered config providers
+  * 
+  * @internal
+  */
+  clearConfigProviders() {
+    this.configProviderMap.clear();
+  }
+  // ============================================================================
+  // Abstract Class Implementation Methods
+  // ============================================================================
+  /**
+  * Register an implementation for an abstract class
+  * 
+  * @param abstractClass - The abstract class being implemented
+  * @param implementation - The concrete implementation class
+  * @param name - Optional name for named implementations
+  * 
+  * @example
+  * ```typescript
+  * registry.registerAbstractImplementation(Mailer, SmtpMailer);
+  * registry.registerAbstractImplementation(Mailer, SendGridMailer, 'sendgrid');
+  * ```
+  */
+  registerAbstractImplementation(abstractClass, implementation, name) {
+    const implementations = this.abstractImplementations.get(abstractClass) ?? [];
+    const existing = implementations.find((i) => i.implementation === implementation);
+    if (!existing) {
+      implementations.push({
+        implementation,
+        isPrimary: false,
+        name
+      });
+      this.abstractImplementations.set(abstractClass, implementations);
+    } else if (name && !existing.name) {
+      existing.name = name;
+    }
+  }
+  /**
+  * Set the name for an implementation
+  * 
+  * @param abstractClass - The abstract class
+  * @param implementation - The implementation class
+  * @param name - The name to assign
+  */
+  setImplementationName(abstractClass, implementation, name) {
+    const implementations = this.abstractImplementations.get(abstractClass);
+    if (!implementations) {
+      return;
+    }
+    const impl = implementations.find((i) => i.implementation === implementation);
+    if (impl) {
+      impl.name = name;
+    }
+  }
+  /**
+  * Set an implementation as the primary for an abstract class
+  * 
+  * @param abstractClass - The abstract class
+  * @param implementation - The implementation to mark as primary
+  */
+  setPrimaryImplementation(abstractClass, implementation) {
+    const implementations = this.abstractImplementations.get(abstractClass);
+    if (!implementations) {
+      return;
+    }
+    for (const impl of implementations) {
+      impl.isPrimary = impl.implementation === implementation;
+    }
+  }
+  /**
+  * Get all implementations for an abstract class.
+  * 
+  * This method only returns the raw metadata - resolution logic 
+  * (deciding which implementation to use) belongs in the Container.
+  * 
+  * @param abstractClass - The abstract class to look up
+  * @returns Array of implementation info, or empty array if none
+  */
+  getImplementations(abstractClass) {
+    return this.abstractImplementations.get(abstractClass) ?? [];
+  }
+  /**
+  * Check if an abstract class has registered implementations
+  * 
+  * @param abstractClass - The abstract class to check
+  * @returns true if at least one implementation exists
+  */
+  hasImplementation(abstractClass) {
+    const implementations = this.abstractImplementations.get(abstractClass);
+    return !!implementations && implementations.length > 0;
+  }
+  /**
+  * Clear all abstract implementations (useful for testing)
+  */
+  clearAbstractImplementations() {
+    this.abstractImplementations.clear();
+  }
+};
+var registry = Registry.getInstance();
+
+// src/core/container/abstract-class.utils.ts
+var IMPLEMENTS_METADATA = /* @__PURE__ */ Symbol("rikta:implements");
+var PRIMARY_METADATA = /* @__PURE__ */ Symbol("rikta:primary");
+function isAbstractClass(target) {
+  if (typeof target !== "function") {
+    return false;
+  }
+  const isMarkedAbstract = Reflect.getMetadata(IMPLEMENTS_METADATA, target) === void 0 && Reflect.hasMetadata("abstract:class", target);
+  if (isMarkedAbstract) {
+    return true;
+  }
+  return Reflect.getMetadata("abstract:class", target) === true;
+}
+__name(isAbstractClass, "isAbstractClass");
+function extendsFrom(derived, base) {
+  if (!derived || !base) {
+    return false;
+  }
+  if (derived === base) {
+    return false;
+  }
+  let current = Object.getPrototypeOf(derived);
+  while (current && current !== Function.prototype) {
+    if (current === base) {
+      return true;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+}
+__name(extendsFrom, "extendsFrom");
+function getImplementedAbstract(target) {
+  return Reflect.getMetadata(IMPLEMENTS_METADATA, target);
+}
+__name(getImplementedAbstract, "getImplementedAbstract");
+function isPrimaryImplementation(target) {
+  return Reflect.getMetadata(PRIMARY_METADATA, target) === true;
+}
+__name(isPrimaryImplementation, "isPrimaryImplementation");
+function setImplementsMetadata(target, abstractClass) {
+  Reflect.defineMetadata(IMPLEMENTS_METADATA, abstractClass, target);
+}
+__name(setImplementsMetadata, "setImplementsMetadata");
+function setPrimaryMetadata(target) {
+  Reflect.defineMetadata(PRIMARY_METADATA, true, target);
+}
+__name(setPrimaryMetadata, "setPrimaryMetadata");
+function markAsAbstract(target) {
+  Reflect.defineMetadata("abstract:class", true, target);
+}
+__name(markAsAbstract, "markAsAbstract");
+
+// src/core/container/request-scope.ts
+var import_node_async_hooks = require("async_hooks");
+var RequestScopeStorage = class _RequestScopeStorage {
+  static {
+    __name(this, "RequestScopeStorage");
+  }
+  static instance;
+  /** AsyncLocalStorage for request-scoped data */
+  asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+  constructor() {
+  }
+  /**
+  * Get the global RequestScopeStorage instance
+  */
+  static getInstance() {
+    if (!_RequestScopeStorage.instance) {
+      _RequestScopeStorage.instance = new _RequestScopeStorage();
+    }
+    return _RequestScopeStorage.instance;
+  }
+  /**
+  * Reset the storage (useful for testing)
+  */
+  static reset() {
+    _RequestScopeStorage.instance = new _RequestScopeStorage();
+  }
+  /**
+  * Run a function within a request scope
+  * All request-scoped dependencies resolved within this function
+  * will be isolated to this request.
+  * 
+  * @param fn - The function to run within the request scope
+  * @returns The result of the function
+  */
+  run(fn) {
+    const store = /* @__PURE__ */ new Map();
+    return this.asyncLocalStorage.run(store, fn);
+  }
+  /**
+  * Run an async function within a request scope
+  * 
+  * @param fn - The async function to run within the request scope
+  * @returns Promise resolving to the function result
+  */
+  async runAsync(fn) {
+    const store = /* @__PURE__ */ new Map();
+    return this.asyncLocalStorage.run(store, fn);
+  }
+  /**
+  * Check if we're currently inside a request scope
+  */
+  isInRequestScope() {
+    return this.asyncLocalStorage.getStore() !== void 0;
+  }
+  /**
+  * Get a request-scoped instance by token
+  * 
+  * @param token - The injection token
+  * @returns The instance if found, undefined otherwise
+  */
+  get(token) {
+    const store = this.asyncLocalStorage.getStore();
+    if (!store) {
+      return void 0;
+    }
+    return store.get(token);
+  }
+  /**
+  * Set a request-scoped instance
+  * 
+  * @param token - The injection token
+  * @param instance - The instance to store
+  * @throws Error if not in a request scope
+  */
+  set(token, instance) {
+    const store = this.asyncLocalStorage.getStore();
+    if (!store) {
+      throw new Error("Cannot set request-scoped instance outside of a request context. Make sure RequestScopeStorage.run() or runAsync() is being used.");
+    }
+    store.set(token, instance);
+  }
+  /**
+  * Check if a request-scoped instance exists
+  * 
+  * @param token - The injection token
+  * @returns true if the instance exists in current request scope
+  */
+  has(token) {
+    const store = this.asyncLocalStorage.getStore();
+    return store?.has(token) ?? false;
+  }
+  /**
+  * Get the current request store (for debugging/testing)
+  * @internal
+  */
+  getStore() {
+    return this.asyncLocalStorage.getStore();
+  }
+};
+var requestScopeStorage = RequestScopeStorage.getInstance();
+
+// src/core/container/container.ts
+var Container = class _Container {
+  static {
+    __name(this, "Container");
+  }
+  static instance;
+  /** Stores singleton instances by token */
+  singletons = /* @__PURE__ */ new Map();
+  /** Stores provider registrations */
+  providers = /* @__PURE__ */ new Map();
+  /** Resolution stack for circular dependency detection */
+  resolutionStack = /* @__PURE__ */ new Set();
+  constructor() {
+  }
+  /**
+  * Get the global container instance
+  */
+  static getInstance() {
+    if (!_Container.instance) {
+      _Container.instance = new _Container();
+    }
+    return _Container.instance;
+  }
+  /**
+  * Reset the container (useful for testing)
+  */
+  static reset() {
+    _Container.instance = new _Container();
+  }
+  /**
+  * Register a class provider in the container
+  */
+  register(target, options = {}) {
+    const scope = options.scope ?? "singleton";
+    this.providers.set(target, {
+      scope
+    });
+  }
+  /**
+  * Register a custom provider (value, factory, class, or existing)
+  */
+  registerProvider(provider) {
+    if (typeof provider === "function") {
+      this.register(provider);
+      return;
+    }
+    const token = provider.provide;
+    if ("useValue" in provider) {
+      this.providers.set(token, {
+        scope: "singleton",
+        provider
+      });
+      this.singletons.set(token, provider.useValue);
+    } else if ("useFactory" in provider) {
+      this.providers.set(token, {
+        scope: "singleton",
+        provider
+      });
+    } else if ("useClass" in provider) {
+      this.providers.set(token, {
+        scope: "singleton",
+        provider
+      });
+    } else if ("useExisting" in provider) {
+      this.providers.set(token, {
+        scope: "singleton",
+        provider
+      });
+    }
+  }
+  /**
+  * Register a value directly
+  */
+  registerValue(token, value) {
+    this.registerProvider({
+      provide: token,
+      useValue: value
+    });
+  }
+  /**
+  * Register a factory function
+  */
+  registerFactory(token, factory, inject) {
+    this.registerProvider({
+      provide: token,
+      useFactory: factory,
+      inject
+    });
+  }
+  /**
+  * Check if a provider is registered
+  */
+  has(token) {
+    return this.providers.has(token);
+  }
+  /**
+  * Resolve a dependency by token
+  */
+  resolve(token) {
+    return this.resolveToken(token, false);
+  }
+  /**
+  * Resolve a dependency, returning undefined if not found (for optional deps)
+  */
+  resolveOptional(token) {
+    return this.resolveToken(token, true);
+  }
+  /**
+  * Internal resolution logic
+  */
+  resolveToken(token, optional) {
+    if (this.resolutionStack.has(token)) {
+      const chain = [
+        ...this.resolutionStack
+      ].map((t) => this.getTokenName(t)).join(" -> ");
+      throw new Error(`Circular dependency detected: ${chain} -> ${this.getTokenName(token)}`);
+    }
+    if (this.singletons.has(token)) {
+      return this.singletons.get(token);
+    }
+    const config = this.providers.get(token);
+    if (!config) {
+      if (typeof token === "function") {
+        const implementation = this.resolveAbstractClass(token);
+        if (implementation) {
+          const instance = this.resolveClass(implementation);
+          this.singletons.set(token, instance);
+          return instance;
+        }
+        if (!isAbstractClass(token)) {
+          return this.resolveClass(token);
+        }
+      }
+      if (optional) {
+        return void 0;
+      }
+      throw new Error(`No provider found for token: ${this.getTokenName(token)}`);
+    }
+    if (config.provider && typeof config.provider !== "function") {
+      return this.resolveProvider(config.provider, config.scope);
+    }
+    if (typeof token === "function") {
+      return this.resolveClass(token);
+    }
+    throw new Error(`Cannot resolve token: ${this.getTokenName(token)}`);
+  }
+  /**
+  * Try to resolve an abstract class to its concrete implementation.
+  * 
+  * This method contains all the resolution logic for abstract classes:
+  * 1. Check for direct provider registration (useClass)
+  * 2. If name specified, find the named implementation
+  * 3. If only one implementation exists, use it
+  * 4. If multiple implementations, use the one marked @Primary
+  * 5. If multiple without @Primary, throw an error
+  * 
+  * @param abstractClass - The abstract class to resolve
+  * @param name - Optional name for named implementation resolution
+  * @returns The concrete implementation class, or undefined if not found
+  */
+  resolveAbstractClass(abstractClass, name) {
+    const config = this.providers.get(abstractClass);
+    if (config?.provider && "useClass" in config.provider) {
+      return config.provider.useClass;
+    }
+    const implementations = registry.getImplementations(abstractClass);
+    if (!implementations || implementations.length === 0) {
+      return void 0;
+    }
+    if (name) {
+      const named = implementations.find((i) => i.name === name);
+      if (named) {
+        return named.implementation;
+      }
+      throw new Error(`No implementation named '${name}' found for abstract class ${abstractClass.name}. Available names: ${implementations.filter((i) => i.name).map((i) => i.name).join(", ") || "none"}`);
+    }
+    if (implementations.length === 1) {
+      return implementations[0].implementation;
+    }
+    const primary = implementations.find((i) => i.isPrimary);
+    if (primary) {
+      return primary.implementation;
+    }
+    const implNames = implementations.map((i) => i.implementation.name).join(", ");
+    throw new Error(`Multiple implementations found for abstract class ${abstractClass.name}: ${implNames}. Use @Primary() to mark one as the default, or @Named() for qualified injection.`);
+  }
+  /**
+  * Resolve a custom provider
+  */
+  resolveProvider(provider, scope) {
+    if (typeof provider === "function") {
+      return this.resolveClass(provider);
+    }
+    const token = provider.provide;
+    if ("useValue" in provider) {
+      return provider.useValue;
+    }
+    if ("useFactory" in provider) {
+      const factoryProvider = provider;
+      const deps = (factoryProvider.inject ?? []).map((dep) => this.resolve(dep));
+      const result = factoryProvider.useFactory(...deps);
+      if (scope === "singleton") {
+        this.singletons.set(token, result);
+      }
+      return result;
+    }
+    if ("useClass" in provider) {
+      const classProvider = provider;
+      const instance = this.resolveClass(classProvider.useClass);
+      if (scope === "singleton") {
+        this.singletons.set(token, instance);
+      }
+      return instance;
+    }
+    if ("useExisting" in provider) {
+      return this.resolve(provider.useExisting);
+    }
+    throw new Error("Invalid provider configuration");
+  }
+  /**
+  * Resolve a class and all its dependencies
+  */
+  resolveClass(target) {
+    if (this.resolutionStack.has(target)) {
+      const chain = [
+        ...this.resolutionStack,
+        target
+      ].map((t) => this.getTokenName(t)).join(" -> ");
+      throw new Error(`Circular dependency detected: ${chain}`);
+    }
+    const providerConfig = this.providers.get(target);
+    const scope = providerConfig?.scope ?? "singleton";
+    if (scope === "singleton" && this.singletons.has(target)) {
+      return this.singletons.get(target);
+    }
+    if (scope === "request") {
+      if (!requestScopeStorage.isInRequestScope()) {
+        throw new Error(`Cannot resolve request-scoped provider '${target.name}' outside of a request context. Request-scoped providers can only be resolved during HTTP request handling.`);
+      }
+      const existingInstance = requestScopeStorage.get(target);
+      if (existingInstance !== void 0) {
+        return existingInstance;
+      }
+    }
+    this.resolutionStack.add(target);
+    try {
+      const injectMeta = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target) ?? [];
+      const maxIndex = injectMeta.length > 0 ? Math.max(...injectMeta.map((m) => m.index ?? -1)) : -1;
+      const paramCount = Math.max(paramTypes.length, maxIndex + 1);
+      const dependencies = [];
+      for (let index = 0; index < paramCount; index++) {
+        const paramType = paramTypes[index];
+        const injectOverride = injectMeta.find((m) => m.index === index);
+        const token = injectOverride?.token ?? paramType;
+        const isOptional = injectOverride?.optional ?? false;
+        const name = injectOverride?.name;
+        if (!token) {
+          if (isOptional) {
+            dependencies.push(void 0);
+            continue;
+          }
+          throw new Error(`Cannot resolve constructor parameter ${index} of ${target.name}. Use @Autowired(token) decorator.`);
+        }
+        if (!injectOverride && this.isPrimitive(paramType)) {
+          if (isOptional) {
+            dependencies.push(void 0);
+            continue;
+          }
+          throw new Error(`Cannot inject primitive type '${paramType?.name ?? "unknown"}' into ${target.name}. Use @Autowired(token) decorator.`);
+        }
+        dependencies.push(isOptional ? this.resolveWithNameOptional(token, name) : this.resolveWithName(token, name));
+      }
+      const instance = new target(...dependencies);
+      this.injectProperties(target, instance);
+      if (scope === "singleton") {
+        this.singletons.set(target, instance);
+      } else if (scope === "request") {
+        requestScopeStorage.set(target, instance);
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.delete(target);
+    }
+  }
+  /**
+  * Inject properties marked with @Autowired()
+  */
+  injectProperties(target, instance) {
+    const autowireMeta = Reflect.getMetadata(AUTOWIRED_METADATA, target) ?? [];
+    for (const meta of autowireMeta) {
+      if (!meta.propertyKey) continue;
+      const isOptional = meta.optional ?? false;
+      try {
+        const value = isOptional ? this.resolveWithNameOptional(meta.token, meta.name) : this.resolveWithName(meta.token, meta.name);
+        instance[meta.propertyKey] = value;
+      } catch (error) {
+        if (!isOptional) {
+          throw error;
+        }
+      }
+    }
+  }
+  /**
+  * Resolve a dependency with optional name for qualified injection
+  */
+  resolveWithName(token, name) {
+    if (name && typeof token === "function") {
+      const implementation = this.resolveAbstractClass(token, name);
+      if (implementation) {
+        return this.resolveClass(implementation);
+      }
+      throw new Error(`No implementation named '${name}' found for ${this.getTokenName(token)}`);
+    }
+    return this.resolve(token);
+  }
+  /**
+  * Resolve a dependency with optional name, returning undefined if not found
+  */
+  resolveWithNameOptional(token, name) {
+    try {
+      return this.resolveWithName(token, name);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+  * Register an existing instance as a singleton
+  */
+  registerInstance(target, instance) {
+    this.providers.set(target, {
+      scope: "singleton"
+    });
+    this.singletons.set(target, instance);
+  }
+  /**
+  * Get all registered providers
+  */
+  getProviders() {
+    return [
+      ...this.providers.keys()
+    ];
+  }
+  /**
+  * Clear all singletons (useful for testing)
+  */
+  clearSingletons() {
+    this.singletons.clear();
+  }
+  /**
+  * Check if a type is a primitive (not injectable)
+  */
+  isPrimitive(type) {
+    if (!type) return true;
+    const primitives = [
+      String,
+      Number,
+      Boolean,
+      Object,
+      Array,
+      Function
+    ];
+    return primitives.includes(type);
+  }
+  /**
+  * Get a human-readable name for a token
+  */
+  getTokenName(token) {
+    if (typeof token === "function") {
+      return token.name;
+    }
+    if (token instanceof InjectionToken) {
+      return token.toString();
+    }
+    if (typeof token === "symbol") {
+      return token.toString();
+    }
+    return String(token);
+  }
+};
+var container = Container.getInstance();
+
+// src/core/container/implements.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function Implements(abstractClass) {
+  return (target) => {
+    setImplementsMetadata(target, abstractClass);
+    markAsAbstract(abstractClass);
+    const name = Reflect.getMetadata("rikta:named", target);
+    registry.registerAbstractImplementation(abstractClass, target, name);
+    const isPrimary = Reflect.getMetadata("rikta:is-primary", target) === true;
+    if (isPrimary) {
+      registry.setPrimaryImplementation(abstractClass, target);
+    }
+  };
+}
+__name(Implements, "Implements");
+function Primary() {
+  return (target) => {
+    setPrimaryMetadata(target);
+    const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
+    if (abstractClass) {
+      registry.setPrimaryImplementation(abstractClass, target);
+    }
+    Reflect.defineMetadata("rikta:is-primary", true, target);
+  };
+}
+__name(Primary, "Primary");
+function Named(name) {
+  return (target) => {
+    Reflect.defineMetadata("rikta:named", name, target);
+    const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
+    if (abstractClass) {
+      registry.setImplementationName(abstractClass, target, name);
+    }
+  };
+}
+__name(Named, "Named");
+function AbstractClass() {
+  return (target) => {
+    markAsAbstract(target);
+  };
+}
+__name(AbstractClass, "AbstractClass");
+
+// src/core/discovery.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
+
+// src/core/exceptions/discovery.exception.ts
+var DiscoveryException = class extends Error {
+  static {
+    __name(this, "DiscoveryException");
+  }
+  /**
+  * The file path that failed to import
+  */
+  filePath;
+  /**
+  * The original error that caused the failure
+  */
+  originalError;
+  /**
+  * List of all failed imports (for batch reporting)
+  */
+  failedImports;
+  constructor(filePathOrFailures, originalError) {
+    if (typeof filePathOrFailures === "string") {
+      const filePath = filePathOrFailures;
+      const error = originalError;
+      super(`[Rikta Discovery] Failed to import module: ${filePath}
+Reason: ${error.message}`);
+      this.filePath = filePath;
+      this.originalError = error;
+      this.failedImports = [
+        {
+          filePath,
+          error
+        }
+      ];
+    } else {
+      const failures = filePathOrFailures;
+      const fileList = failures.map((f) => `  - ${f.filePath}: ${f.error.message}`).join("\n");
+      super(`[Rikta Discovery] Failed to import ${failures.length} module(s):
+${fileList}`);
+      this.filePath = failures[0]?.filePath ?? "";
+      this.originalError = failures[0]?.error ?? new Error("Unknown error");
+      this.failedImports = failures;
+    }
+    this.name = "DiscoveryException";
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+  * Get a formatted report of all failed imports
+  */
+  getReport() {
+    const lines = [
+      "Discovery Failures:",
+      ""
+    ];
+    for (const { filePath, error } of this.failedImports) {
+      lines.push(`\u{1F4C1} ${filePath}`);
+      lines.push(`   Error: ${error.message}`);
+      if (error.stack) {
+        const stackLines = error.stack.split("\n").slice(1, 4);
+        lines.push(`   Stack: ${stackLines.join("\n          ")}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/core/discovery.ts
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/benchmarks/**",
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/*.d.ts"
+];
+function getEntryPointDirectory() {
+  const mainScript = process.argv[1];
+  if (mainScript) {
+    const filePath = mainScript.startsWith("file://") ? new URL(mainScript).pathname : mainScript;
+    return import_path.default.dirname(filePath);
+  }
+  return process.cwd();
+}
+__name(getEntryPointDirectory, "getEntryPointDirectory");
+var DECORATOR_PATTERNS = [
+  // TypeScript source patterns
+  /@Controller\s*\(/,
+  /@Injectable\s*\(/,
+  /@Provider\s*\(/,
+  // Compiled JavaScript CommonJS patterns (e.g., (0, core_1.Controller)('/path'))
+  /\.\s*Controller\s*\)\s*\(/,
+  /\.\s*Injectable\s*\)\s*\(/,
+  /\.\s*Provider\s*\)\s*\(/,
+  /\.\s*ProviderConfig\s*\)\s*\(/,
+  // ESM compiled patterns - import statements with decorators
+  /import\s*{\s*[^}]*\bController\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/,
+  /import\s*{\s*[^}]*\bInjectable\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/,
+  /import\s*{\s*[^}]*\bProvider\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/
+];
+async function containsRiktaDecorators(filePath) {
+  try {
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return DECORATOR_PATTERNS.some((pattern) => pattern.test(content));
+  } catch {
+    return false;
+  }
+}
+__name(containsRiktaDecorators, "containsRiktaDecorators");
+async function discoverModules(optionsOrPatterns = [
+  "./**/*.{ts,js}"
+], cwd) {
+  const options = Array.isArray(optionsOrPatterns) ? {
+    patterns: optionsOrPatterns,
+    cwd
+  } : optionsOrPatterns;
+  const patterns = options.patterns ?? [
+    "./**/*.{ts,js}"
+  ];
+  const strict = options.strict ?? false;
+  const onImportError = options.onImportError;
+  const baseDir = options.cwd ?? cwd ?? getEntryPointDirectory();
+  const absoluteBaseDir = import_path.default.isAbsolute(baseDir) ? baseDir : import_path.default.resolve(process.cwd(), baseDir);
+  const normalizedPatterns = patterns.map((pattern) => {
+    let normalizedPattern = pattern;
+    if (import_path.default.isAbsolute(pattern)) {
+      normalizedPattern = import_path.default.relative(absoluteBaseDir, pattern);
+      if (!normalizedPattern.startsWith(".")) {
+        normalizedPattern = "./" + normalizedPattern;
+      }
+    }
+    if (/\.\w+$/.test(normalizedPattern) || normalizedPattern.endsWith("*")) {
+      return normalizedPattern;
+    }
+    return normalizedPattern.endsWith("/") ? `${normalizedPattern}**/*.{ts,js}` : `${normalizedPattern}/**/*.{ts,js}`;
+  });
+  const files = await (0, import_fast_glob.default)(normalizedPatterns, {
+    cwd: absoluteBaseDir,
+    absolute: true,
+    ignore: DEFAULT_IGNORE_PATTERNS,
+    onlyFiles: true
+  });
+  const decoratorChecks = await Promise.all(files.map(async (file) => ({
+    file,
+    hasDecorators: await containsRiktaDecorators(file)
+  })));
+  const riktaFiles = decoratorChecks.filter(({ hasDecorators }) => hasDecorators).map(({ file }) => file);
+  const importedFiles = [];
+  const failedImports = [];
+  for (const file of riktaFiles) {
+    try {
+      let importPath;
+      if (file.endsWith(".js")) {
+        importPath = `file://${file}`;
+      } else {
+        importPath = file.replace(/\.ts$/, "");
+      }
+      await import(importPath);
+      importedFiles.push(file);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      onImportError?.(file, error);
+      if (process.env.DEBUG) {
+        console.warn(`[Rikta] Failed to import ${file}:`, error.message);
+      }
+      failedImports.push({
+        filePath: file,
+        error
+      });
+    }
+  }
+  if (strict && failedImports.length > 0) {
+    throw new DiscoveryException(failedImports);
+  }
+  return importedFiles;
+}
+__name(discoverModules, "discoverModules");
+function getCallerDirectory() {
+  return getEntryPointDirectory();
+}
+__name(getCallerDirectory, "getCallerDirectory");
+
+// src/core/decorators/injectable.decorator.ts
+var import_reflect_metadata3 = require("reflect-metadata");
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(INJECTABLE_METADATA, options, target);
+    container.register(target, options);
+    registry.registerProvider(target);
+  };
+}
+__name(Injectable, "Injectable");
+
+// src/core/lifecycle/event-bus.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var EventBus = class {
+  static {
+    __name(this, "EventBus");
+  }
+  listeners = /* @__PURE__ */ new Map();
+  onceListeners = /* @__PURE__ */ new Map();
+  /** Track unsubscribe functions by owner for cleanup */
+  ownerUnsubscribers = /* @__PURE__ */ new Map();
+  on(event, listener, owner) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const tracked = {
+      listener,
+      owner
+    };
+    this.listeners.get(event).add(tracked);
+    const unsubscribe = /* @__PURE__ */ __name(() => {
+      this.listeners.get(event)?.delete(tracked);
+      if (owner) {
+        this.ownerUnsubscribers.get(owner)?.delete(unsubscribe);
+      }
+    }, "unsubscribe");
+    if (owner) {
+      if (!this.ownerUnsubscribers.has(owner)) {
+        this.ownerUnsubscribers.set(owner, /* @__PURE__ */ new Set());
+      }
+      this.ownerUnsubscribers.get(owner).add(unsubscribe);
+    }
+    return unsubscribe;
+  }
+  once(event, listener, owner) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const tracked = {
+      listener,
+      owner
+    };
+    this.onceListeners.get(event).add(tracked);
+    if (owner) {
+      if (!this.ownerUnsubscribers.has(owner)) {
+        this.ownerUnsubscribers.set(owner, /* @__PURE__ */ new Set());
+      }
+      const unsubscribe = /* @__PURE__ */ __name(() => {
+        this.onceListeners.get(event)?.delete(tracked);
+      }, "unsubscribe");
+      this.ownerUnsubscribers.get(owner).add(unsubscribe);
+    }
+  }
+  async emit(event, payload) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const { listener } of listeners) {
+        await listener(payload);
+      }
+    }
+    const onceListeners = this.onceListeners.get(event);
+    if (onceListeners) {
+      for (const { listener } of onceListeners) {
+        await listener(payload);
+      }
+      this.onceListeners.delete(event);
+    }
+  }
+  waitFor(event) {
+    return new Promise((resolve2) => this.once(event, resolve2));
+  }
+  /**
+  * Remove all listeners for an event
+  */
+  off(event) {
+    this.listeners.delete(event);
+    this.onceListeners.delete(event);
+  }
+  /**
+  * Remove all listeners registered by a specific owner
+  * Useful for cleaning up when a provider is destroyed
+  * 
+  * @param owner - The owner identifier (usually class name)
+  */
+  removeByOwner(owner) {
+    const unsubscribers = this.ownerUnsubscribers.get(owner);
+    if (unsubscribers) {
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+      }
+      this.ownerUnsubscribers.delete(owner);
+    }
+  }
+  /**
+  * Remove all listeners
+  */
+  clear() {
+    this.listeners.clear();
+    this.onceListeners.clear();
+    this.ownerUnsubscribers.clear();
+  }
+  /**
+  * Get listener count for an event
+  */
+  listenerCount(event) {
+    return (this.listeners.get(event)?.size ?? 0) + (this.onceListeners.get(event)?.size ?? 0);
+  }
+  /**
+  * Get total listener count across all events
+  * Useful for debugging memory leaks
+  */
+  totalListenerCount() {
+    let count = 0;
+    for (const listeners of this.listeners.values()) {
+      count += listeners.size;
+    }
+    for (const listeners of this.onceListeners.values()) {
+      count += listeners.size;
+    }
+    return count;
+  }
+  /**
+  * Get listener count by owner
+  * Useful for debugging which providers have the most listeners
+  */
+  listenerCountByOwner(owner) {
+    return this.ownerUnsubscribers.get(owner)?.size ?? 0;
+  }
+  /**
+  * Get all registered owners
+  */
+  getOwners() {
+    return [
+      ...this.ownerUnsubscribers.keys()
+    ];
+  }
+};
+EventBus = _ts_decorate([
+  Injectable()
+], EventBus);
+
+// src/core/lifecycle/on.decorator.ts
+var import_reflect_metadata4 = require("reflect-metadata");
+var ON_EVENT_METADATA = /* @__PURE__ */ Symbol("on:event:metadata");
+function On(event, options) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(ON_EVENT_METADATA, target.constructor) ?? [];
+    existing.push({
+      event,
+      methodName: String(propertyKey),
+      priority: options?.priority ?? 0
+    });
+    Reflect.defineMetadata(ON_EVENT_METADATA, existing, target.constructor);
+  };
+}
+__name(On, "On");
+
+// src/core/router/router.ts
+var import_reflect_metadata9 = require("reflect-metadata");
+
+// src/core/decorators/create-param-decorator.ts
+var import_reflect_metadata5 = require("reflect-metadata");
+var CUSTOM_PARAM_METADATA = /* @__PURE__ */ Symbol.for("rikta:custom:param:metadata");
+function createParamDecorator(factory) {
+  return (data) => {
+    return (target, propertyKey, parameterIndex) => {
+      if (propertyKey === void 0) return;
+      const existingParams = Reflect.getMetadata(CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
+      const metadata = {
+        index: parameterIndex,
+        factory,
+        data
+      };
+      existingParams.push(metadata);
+      Reflect.defineMetadata(CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
+    };
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+function getCustomParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
+}
+__name(getCustomParamMetadata, "getCustomParamMetadata");
+
+// src/core/exceptions/http-exception.ts
+var HttpException = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  /**
+  * HTTP status code
+  */
+  statusCode;
+  /**
+  * Error response object
+  */
+  response;
+  /**
+  * Timestamp when the exception was created
+  */
+  timestamp;
+  constructor(response, statusCode = 500) {
+    const message = typeof response === "string" ? response : response.message;
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (typeof response === "string") {
+      this.response = {
+        statusCode,
+        message,
+        error: this.getDefaultError(statusCode),
+        timestamp: this.timestamp
+      };
+    } else {
+      this.response = {
+        statusCode,
+        message: response.message,
+        error: response.error ?? this.getDefaultError(statusCode),
+        timestamp: this.timestamp,
+        ...response.details ? {
+          details: response.details
+        } : {},
+        ...response.code ? {
+          code: response.code
+        } : {}
+      };
+    }
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+  * Get the response object for JSON serialization
+  */
+  getResponse() {
+    return this.response;
+  }
+  /**
+  * Get the HTTP status code
+  */
+  getStatus() {
+    return this.statusCode;
+  }
+  /**
+  * Get default error name for status code
+  */
+  getDefaultError(statusCode) {
+    const errors = {
+      400: "Bad Request",
+      401: "Unauthorized",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      406: "Not Acceptable",
+      408: "Request Timeout",
+      409: "Conflict",
+      410: "Gone",
+      413: "Payload Too Large",
+      415: "Unsupported Media Type",
+      422: "Unprocessable Entity",
+      429: "Too Many Requests",
+      500: "Internal Server Error",
+      501: "Not Implemented",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout"
+    };
+    return errors[statusCode] ?? "Error";
+  }
+};
+
+// src/core/exceptions/validation.exception.ts
+var ValidationException = class extends HttpException {
+  static {
+    __name(this, "ValidationException");
+  }
+  /**
+  * The original Zod error object
+  */
+  zodError;
+  /**
+  * Structured validation error details
+  */
+  errors;
+  constructor(zodError, message = "Validation failed") {
+    const errors = zodError.issues.map((issue) => ({
+      path: issue.path,
+      message: issue.message,
+      code: issue.code,
+      ..."expected" in issue ? {
+        expected: String(issue.expected)
+      } : {},
+      ..."received" in issue ? {
+        received: String(issue.received)
+      } : {}
+    }));
+    super({
+      message,
+      error: "Validation Error",
+      details: {
+        errors,
+        errorCount: errors.length
+      }
+    }, 400);
+    this.zodError = zodError;
+    this.errors = errors;
+  }
+  /**
+  * Get formatted errors for client response
+  */
+  getValidationErrors() {
+    return this.errors;
+  }
+  /**
+  * Get the flattened Zod error format
+  */
+  getFlattenedErrors() {
+    return this.zodError.flatten();
+  }
+  /**
+  * Get the formatted Zod error
+  */
+  getFormattedErrors() {
+    return this.zodError.format();
+  }
+};
+
+// src/core/exceptions/exceptions.ts
+var BadRequestException = class extends HttpException {
+  static {
+    __name(this, "BadRequestException");
+  }
+  constructor(response = "Bad Request") {
+    super(response, 400);
+  }
+};
+var UnauthorizedException = class extends HttpException {
+  static {
+    __name(this, "UnauthorizedException");
+  }
+  constructor(response = "Unauthorized") {
+    super(response, 401);
+  }
+};
+var ForbiddenException = class extends HttpException {
+  static {
+    __name(this, "ForbiddenException");
+  }
+  constructor(response = "Forbidden") {
+    super(response, 403);
+  }
+};
+var NotFoundException = class extends HttpException {
+  static {
+    __name(this, "NotFoundException");
+  }
+  constructor(response = "Not Found") {
+    super(response, 404);
+  }
+};
+var MethodNotAllowedException = class extends HttpException {
+  static {
+    __name(this, "MethodNotAllowedException");
+  }
+  constructor(response = "Method Not Allowed") {
+    super(response, 405);
+  }
+};
+var NotAcceptableException = class extends HttpException {
+  static {
+    __name(this, "NotAcceptableException");
+  }
+  constructor(response = "Not Acceptable") {
+    super(response, 406);
+  }
+};
+var RequestTimeoutException = class extends HttpException {
+  static {
+    __name(this, "RequestTimeoutException");
+  }
+  constructor(response = "Request Timeout") {
+    super(response, 408);
+  }
+};
+var ConflictException = class extends HttpException {
+  static {
+    __name(this, "ConflictException");
+  }
+  constructor(response = "Conflict") {
+    super(response, 409);
+  }
+};
+var GoneException = class extends HttpException {
+  static {
+    __name(this, "GoneException");
+  }
+  constructor(response = "Gone") {
+    super(response, 410);
+  }
+};
+var PayloadTooLargeException = class extends HttpException {
+  static {
+    __name(this, "PayloadTooLargeException");
+  }
+  constructor(response = "Payload Too Large") {
+    super(response, 413);
+  }
+};
+var UnsupportedMediaTypeException = class extends HttpException {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
+  constructor(response = "Unsupported Media Type") {
+    super(response, 415);
+  }
+};
+var UnprocessableEntityException = class extends HttpException {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
+  constructor(response = "Unprocessable Entity") {
+    super(response, 422);
+  }
+};
+var TooManyRequestsException = class extends HttpException {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  constructor(response = "Too Many Requests") {
+    super(response, 429);
+  }
+};
+var InternalServerErrorException = class extends HttpException {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
+  constructor(response = "Internal Server Error") {
+    super(response, 500);
+  }
+};
+var NotImplementedException = class extends HttpException {
+  static {
+    __name(this, "NotImplementedException");
+  }
+  constructor(response = "Not Implemented") {
+    super(response, 501);
+  }
+};
+var BadGatewayException = class extends HttpException {
+  static {
+    __name(this, "BadGatewayException");
+  }
+  constructor(response = "Bad Gateway") {
+    super(response, 502);
+  }
+};
+var ServiceUnavailableException = class extends HttpException {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
+  constructor(response = "Service Unavailable") {
+    super(response, 503);
+  }
+};
+var GatewayTimeoutException = class extends HttpException {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
+  constructor(response = "Gateway Timeout") {
+    super(response, 504);
+  }
+};
+
+// src/core/guards/execution-context.ts
+var ExecutionContextImpl = class {
+  static {
+    __name(this, "ExecutionContextImpl");
+  }
+  request;
+  reply;
+  controllerClass;
+  handlerName;
+  httpHost;
+  constructor(request, reply, controllerClass, handlerName) {
+    this.request = request;
+    this.reply = reply;
+    this.controllerClass = controllerClass;
+    this.handlerName = handlerName;
+    this.httpHost = {
+      getRequest: /* @__PURE__ */ __name(() => this.request, "getRequest"),
+      getResponse: /* @__PURE__ */ __name(() => this.reply, "getResponse")
+    };
+  }
+  switchToHttp() {
+    return this.httpHost;
+  }
+  getRequest() {
+    return this.request;
+  }
+  getReply() {
+    return this.reply;
+  }
+  getClass() {
+    return this.controllerClass;
+  }
+  getHandler() {
+    return this.handlerName;
+  }
+  getMetadata(key) {
+    return Reflect.getMetadata(key, this.controllerClass, this.handlerName);
+  }
+};
+
+// src/core/guards/use-guards.decorator.ts
+var import_reflect_metadata6 = require("reflect-metadata");
+function UseGuards(...guards) {
+  return (target, propertyKey) => {
+    if (propertyKey !== void 0) {
+      const existingGuards = Reflect.getMetadata(GUARDS_METADATA, target.constructor, propertyKey) ?? [];
+      Reflect.defineMetadata(GUARDS_METADATA, [
+        ...existingGuards,
+        ...guards
+      ], target.constructor, propertyKey);
+    } else {
+      const existingGuards = Reflect.getMetadata(GUARDS_METADATA, target) ?? [];
+      Reflect.defineMetadata(GUARDS_METADATA, [
+        ...existingGuards,
+        ...guards
+      ], target);
+    }
+  };
+}
+__name(UseGuards, "UseGuards");
+function getGuardsMetadata(target, propertyKey) {
+  const classGuards = Reflect.getMetadata(GUARDS_METADATA, target) ?? [];
+  if (!propertyKey) {
+    return classGuards;
+  }
+  const methodGuards = Reflect.getMetadata(GUARDS_METADATA, target, propertyKey) ?? [];
+  return [
+    ...classGuards,
+    ...methodGuards
+  ];
+}
+__name(getGuardsMetadata, "getGuardsMetadata");
+
+// src/core/middleware/use-middleware.decorator.ts
+var import_reflect_metadata7 = require("reflect-metadata");
+function UseMiddleware(...middleware) {
+  return (target, propertyKey) => {
+    if (propertyKey !== void 0) {
+      const existingMiddleware = Reflect.getMetadata(MIDDLEWARE_METADATA, target.constructor, propertyKey) ?? [];
+      Reflect.defineMetadata(MIDDLEWARE_METADATA, [
+        ...existingMiddleware,
+        ...middleware
+      ], target.constructor, propertyKey);
+    } else {
+      const existingMiddleware = Reflect.getMetadata(MIDDLEWARE_METADATA, target) ?? [];
+      Reflect.defineMetadata(MIDDLEWARE_METADATA, [
+        ...existingMiddleware,
+        ...middleware
+      ], target);
+    }
+  };
+}
+__name(UseMiddleware, "UseMiddleware");
+function getMiddlewareMetadata(target, propertyKey) {
+  const controllerMiddleware = Reflect.getMetadata(MIDDLEWARE_METADATA, target) ?? [];
+  if (!propertyKey) {
+    return controllerMiddleware;
+  }
+  const methodMiddleware = Reflect.getMetadata(MIDDLEWARE_METADATA, target, propertyKey) ?? [];
+  return [
+    ...controllerMiddleware,
+    ...methodMiddleware
+  ];
+}
+__name(getMiddlewareMetadata, "getMiddlewareMetadata");
+
+// src/core/interceptors/use-interceptors.decorator.ts
+var import_reflect_metadata8 = require("reflect-metadata");
+function UseInterceptors(...interceptors) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && descriptor) {
+      const existingInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, target.constructor, propertyKey) ?? [];
+      Reflect.defineMetadata(INTERCEPTORS_METADATA, [
+        ...existingInterceptors,
+        ...interceptors
+      ], target.constructor, propertyKey);
+    } else {
+      const existingInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, target) ?? [];
+      Reflect.defineMetadata(INTERCEPTORS_METADATA, [
+        ...existingInterceptors,
+        ...interceptors
+      ], target);
+    }
+  };
+}
+__name(UseInterceptors, "UseInterceptors");
+function getInterceptorsMetadata(controllerClass, methodName) {
+  const controllerInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, controllerClass) ?? [];
+  const methodInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, controllerClass, methodName) ?? [];
+  return [
+    ...controllerInterceptors,
+    ...methodInterceptors
+  ];
+}
+__name(getInterceptorsMetadata, "getInterceptorsMetadata");
+
+// src/core/router/router.ts
+var Router = class {
+  static {
+    __name(this, "Router");
+  }
+  server;
+  container;
+  globalPrefix;
+  /** Cache for guard instances (singleton per guard class) */
+  guardCache = /* @__PURE__ */ new Map();
+  /** Cache for middleware instances (singleton per middleware class) */
+  middlewareCache = /* @__PURE__ */ new Map();
+  /** Cache for interceptor instances (singleton per interceptor class) */
+  interceptorCache = /* @__PURE__ */ new Map();
+  constructor(server, container2, globalPrefix = "") {
+    this.server = server;
+    this.container = container2;
+    this.globalPrefix = globalPrefix;
+  }
+  /**
+  * Clear the guard instance cache
+  * Useful for testing when you need fresh guard instances
+  */
+  clearGuardCache() {
+    this.guardCache.clear();
+  }
+  /**
+  * Clear the middleware instance cache
+  * Useful for testing when you need fresh middleware instances
+  */
+  clearMiddlewareCache() {
+    this.middlewareCache.clear();
+  }
+  /**
+  * Clear the interceptor instance cache
+  * Useful for testing when you need fresh interceptor instances
+  */
+  clearInterceptorCache() {
+    this.interceptorCache.clear();
+  }
+  /**
+  * Clear all caches (guards, middleware, and interceptors)
+  * Useful for testing or hot-reload scenarios
+  */
+  clearAllCaches() {
+    this.guardCache.clear();
+    this.middlewareCache.clear();
+    this.interceptorCache.clear();
+  }
+  /**
+  * Get the number of cached guard instances
+  */
+  getGuardCacheSize() {
+    return this.guardCache.size;
+  }
+  /**
+  * Get the number of cached middleware instances
+  */
+  getMiddlewareCacheSize() {
+    return this.middlewareCache.size;
+  }
+  /**
+  * Get the number of cached interceptor instances
+  */
+  getInterceptorCacheSize() {
+    return this.interceptorCache.size;
+  }
+  /**
+  * Register all routes from a controller
+  */
+  registerController(controllerClass, silent = false) {
+    const controllerMeta = Reflect.getMetadata(CONTROLLER_METADATA, controllerClass);
+    if (!controllerMeta) {
+      throw new Error(`${controllerClass.name} is not decorated with @Controller(). Make sure to add the decorator.`);
+    }
+    const controllerInstance = this.container.resolve(controllerClass);
+    const routes = Reflect.getMetadata(ROUTES_METADATA, controllerClass) ?? [];
+    for (const route of routes) {
+      this.registerRoute(controllerClass, controllerInstance, controllerMeta.prefix, route, silent);
+    }
+  }
+  /**
+  * Register a single route
+  */
+  registerRoute(controllerClass, controllerInstance, controllerPrefix, route, silent = false) {
+    const fullPath = this.buildPath(controllerPrefix, route.path);
+    const handler = controllerInstance[route.handlerName];
+    if (typeof handler !== "function") {
+      throw new Error(`Handler ${String(route.handlerName)} not found on ${controllerClass.name}`);
+    }
+    const paramsMeta = Reflect.getMetadata(PARAM_METADATA, controllerClass, route.handlerName) ?? [];
+    const customParamsMeta = getCustomParamMetadata(controllerClass, route.handlerName);
+    const statusCode = Reflect.getMetadata(HTTP_CODE_METADATA, controllerClass, route.handlerName);
+    const guards = getGuardsMetadata(controllerClass, route.handlerName);
+    const middleware = getMiddlewareMetadata(controllerClass, route.handlerName);
+    const interceptors = getInterceptorsMetadata(controllerClass, route.handlerName);
+    const compiledResolvers = this.compileParamResolvers(paramsMeta);
+    const hasBuiltinParams = compiledResolvers.length > 0;
+    const hasCustomParams = customParamsMeta.length > 0;
+    const hasParams = hasBuiltinParams || hasCustomParams;
+    const allParamIndexes = [
+      ...compiledResolvers.map((r) => r.index),
+      ...customParamsMeta.map((r) => r.index)
+    ];
+    const maxParamIndex = hasParams ? Math.max(...allParamIndexes) : -1;
+    const guardInstances = this.resolveGuardInstances(guards);
+    const hasGuards = guardInstances.length > 0;
+    const middlewareInstances = this.resolveMiddlewareInstances(middleware);
+    const hasMiddleware = middlewareInstances.length > 0;
+    const interceptorInstances = this.resolveInterceptorInstances(interceptors);
+    const hasInterceptors = interceptorInstances.length > 0;
+    const needsContext = hasGuards || hasCustomParams || hasInterceptors;
+    const createContext = needsContext ? (req, rep) => new ExecutionContextImpl(req, rep, controllerClass, route.handlerName) : null;
+    const executeHandler = /* @__PURE__ */ __name(async (request, reply) => {
+      const executionContext = createContext ? createContext(request, reply) : null;
+      if (hasGuards && executionContext) {
+        await this.executeGuardsOptimized(guardInstances, executionContext);
+      }
+      if (hasMiddleware) {
+        await this.executeMiddlewareChain(middlewareInstances, request, reply);
+      }
+      const coreHandler = /* @__PURE__ */ __name(async () => {
+        let args;
+        if (hasParams) {
+          args = await this.resolveAllParams(compiledResolvers, customParamsMeta, maxParamIndex, request, reply, executionContext);
+        }
+        const result2 = args ? await handler.apply(controllerInstance, args) : await handler.call(controllerInstance);
+        return result2;
+      }, "coreHandler");
+      let result;
+      if (hasInterceptors && executionContext) {
+        result = await this.executeInterceptorChain(interceptorInstances, executionContext, coreHandler);
+      } else {
+        result = await coreHandler();
+      }
+      if (statusCode) reply.status(statusCode);
+      return result;
+    }, "executeHandler");
+    const routeHandler = /* @__PURE__ */ __name(async (request, reply) => {
+      return requestScopeStorage.runAsync(() => executeHandler(request, reply));
+    }, "routeHandler");
+    const method = route.method.toLowerCase();
+    this.server[method](fullPath, routeHandler);
+    if (!silent) console.log(`  \u2192 ${route.method.padEnd(7)} ${fullPath}`);
+  }
+  /**
+  * OPTIMIZATION: Compile parameter resolvers at route registration time
+  * Each resolver is a pre-built extractor function
+  */
+  compileParamResolvers(paramsMeta) {
+    if (paramsMeta.length === 0) return [];
+    return paramsMeta.map((param) => {
+      const extractor = this.createParamExtractor(param);
+      return {
+        index: param.index,
+        extract: extractor,
+        zodSchema: param.zodSchema,
+        validationLabel: `${param.type}${param.key ? ` (${param.key})` : ""}`
+      };
+    });
+  }
+  /**
+  * OPTIMIZATION: Create a specialized extractor function for each param type
+  * This avoids switch statements at runtime
+  */
+  createParamExtractor(param) {
+    const key = param.key;
+    switch (param.type) {
+      case ParamType.BODY:
+        return key ? (ctx) => ctx.body?.[key] : (ctx) => ctx.body;
+      case ParamType.QUERY:
+        return key ? (ctx) => ctx.query[key] : (ctx) => ctx.query;
+      case ParamType.PARAM:
+        return key ? (ctx) => ctx.params[key] : (ctx) => ctx.params;
+      case ParamType.HEADERS:
+        const headerKey = key?.toLowerCase();
+        return headerKey ? (ctx) => ctx.request.headers[headerKey] : (ctx) => ctx.request.headers;
+      case ParamType.REQUEST:
+        return (ctx) => ctx.request;
+      case ParamType.REPLY:
+        return (ctx) => ctx.reply;
+      case ParamType.CONTEXT:
+        return (ctx) => ctx;
+      default:
+        return () => void 0;
+    }
+  }
+  /**
+  * Resolve all parameters including both built-in and custom param decorators
+  */
+  async resolveAllParams(compiledResolvers, customParams, maxIndex, request, reply, executionContext) {
+    const routeContext = {
+      request,
+      reply,
+      params: request.params,
+      query: request.query,
+      body: request.body
+    };
+    const args = new Array(maxIndex + 1);
+    for (let i = 0; i < compiledResolvers.length; i++) {
+      const resolver = compiledResolvers[i];
+      let value = resolver.extract(routeContext);
+      if (resolver.zodSchema) {
+        const result = resolver.zodSchema.safeParse(value);
+        if (!result.success) {
+          throw new ValidationException(result.error, `Validation failed for ${resolver.validationLabel}`);
+        }
+        value = result.data;
+      }
+      args[resolver.index] = value;
+    }
+    if (customParams.length > 0) {
+      const ctx = executionContext ?? new ExecutionContextImpl(request, reply, {}, "");
+      for (const customParam of customParams) {
+        const value = await customParam.factory(customParam.data, ctx);
+        args[customParam.index] = value;
+      }
+    }
+    return args;
+  }
+  /**
+  * OPTIMIZATION: Pre-resolve guard instances at route registration
+  */
+  resolveGuardInstances(guards) {
+    return guards.map((GuardClass) => {
+      let instance = this.guardCache.get(GuardClass);
+      if (instance) return instance;
+      try {
+        instance = this.container.resolve(GuardClass);
+      } catch (error) {
+        throw new Error(`Failed to resolve guard ${GuardClass.name}. Make sure it is decorated with @Injectable(). Original error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (typeof instance.canActivate !== "function") {
+        throw new Error(`${GuardClass.name} does not implement CanActivate interface. The guard must have a canActivate(context: ExecutionContext) method.`);
+      }
+      this.guardCache.set(GuardClass, instance);
+      return instance;
+    });
+  }
+  /**
+  * OPTIMIZATION: Execute guards using pre-resolved instances
+  */
+  async executeGuardsOptimized(guardInstances, context) {
+    for (let i = 0; i < guardInstances.length; i++) {
+      const result = await guardInstances[i].canActivate(context);
+      if (result !== true) {
+        throw new ForbiddenException(`Access denied by guard`);
+      }
+    }
+  }
+  /**
+  * OPTIMIZATION: Pre-resolve middleware instances at route registration
+  */
+  resolveMiddlewareInstances(middleware) {
+    return middleware.map((MiddlewareClass) => {
+      let instance = this.middlewareCache.get(MiddlewareClass);
+      if (instance) return instance;
+      try {
+        instance = this.container.resolve(MiddlewareClass);
+      } catch (error) {
+        throw new Error(`Failed to resolve middleware ${MiddlewareClass.name}. Make sure it is decorated with @Injectable(). Original error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (typeof instance.use !== "function") {
+        throw new Error(`${MiddlewareClass.name} does not implement RiktaMiddleware interface. The middleware must have a use(req, res, next) method.`);
+      }
+      this.middlewareCache.set(MiddlewareClass, instance);
+      return instance;
+    });
+  }
+  /**
+  * Execute middleware chain in order
+  * Each middleware must call next() to continue
+  */
+  async executeMiddlewareChain(middlewareInstances, request, reply) {
+    let index = 0;
+    const next = /* @__PURE__ */ __name(async () => {
+      if (index < middlewareInstances.length) {
+        const middleware = middlewareInstances[index++];
+        await middleware.use(request, reply, next);
+      }
+    }, "next");
+    await next();
+  }
+  /**
+  * OPTIMIZATION: Pre-resolve interceptor instances at route registration
+  */
+  resolveInterceptorInstances(interceptors) {
+    return interceptors.map((InterceptorClass) => {
+      let instance = this.interceptorCache.get(InterceptorClass);
+      if (instance) return instance;
+      try {
+        instance = this.container.resolve(InterceptorClass);
+      } catch (error) {
+        throw new Error(`Failed to resolve interceptor ${InterceptorClass.name}. Make sure it is decorated with @Injectable(). Original error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (typeof instance.intercept !== "function") {
+        throw new Error(`${InterceptorClass.name} does not implement Interceptor interface. The interceptor must have an intercept(context, next) method.`);
+      }
+      this.interceptorCache.set(InterceptorClass, instance);
+      return instance;
+    });
+  }
+  /**
+  * Execute interceptor chain
+  * Each interceptor wraps around the next, creating an onion-like execution
+  */
+  async executeInterceptorChain(interceptorInstances, context, coreHandler) {
+    let handler = coreHandler;
+    for (let i = interceptorInstances.length - 1; i >= 0; i--) {
+      const interceptor = interceptorInstances[i];
+      const nextHandler = handler;
+      handler = /* @__PURE__ */ __name(() => {
+        const callHandler = {
+          handle: /* @__PURE__ */ __name(() => nextHandler(), "handle")
+        };
+        return interceptor.intercept(context, callHandler);
+      }, "handler");
+    }
+    return handler();
+  }
+  /**
+  * Build the full route path
+  */
+  buildPath(controllerPrefix, routePath) {
+    const parts = [
+      this.globalPrefix,
+      controllerPrefix,
+      routePath
+    ].filter(Boolean).join("");
+    return parts.replace(/\/+/g, "/") || "/";
+  }
+};
+
+// src/core/application.ts
+var import_reflect_metadata11 = require("reflect-metadata");
+var import_fastify = __toESM(require("fastify"), 1);
+
+// src/core/exceptions/exception-filter.ts
+var GlobalExceptionFilter = class {
+  static {
+    __name(this, "GlobalExceptionFilter");
+  }
+  includeStack;
+  logErrors;
+  constructor(options = {}) {
+    this.includeStack = options.includeStack ?? process.env.NODE_ENV !== "production";
+    this.logErrors = options.logErrors ?? true;
+  }
+  /**
+  * Handle any exception and send standardized response
+  */
+  catch(exception, context) {
+    const { request, reply, path: path2, method } = context;
+    const requestId = request.id ?? void 0;
+    if (this.logErrors) {
+      this.logError(exception, method, path2, requestId);
+    }
+    const response = this.buildResponse(exception, path2, requestId);
+    reply.status(response.statusCode).send(response);
+  }
+  /**
+  * Build standardized error response
+  */
+  buildResponse(exception, path2, requestId) {
+    if (exception instanceof HttpException) {
+      const httpResponse = exception.getResponse();
+      return {
+        statusCode: httpResponse.statusCode,
+        message: httpResponse.message,
+        error: httpResponse.error,
+        timestamp: httpResponse.timestamp,
+        path: path2,
+        ...requestId ? {
+          requestId
+        } : {},
+        ...httpResponse.details ? {
+          details: httpResponse.details
+        } : {},
+        ...httpResponse.code ? {
+          code: httpResponse.code
+        } : {},
+        ...this.includeStack ? {
+          stack: exception.stack
+        } : {}
+      };
+    }
+    if (this.isFastifyValidationError(exception)) {
+      return {
+        statusCode: 400,
+        message: "Validation failed",
+        error: "Bad Request",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        path: path2,
+        ...requestId && {
+          requestId
+        },
+        details: exception.validation,
+        ...this.includeStack && {
+          stack: exception.stack
+        }
+      };
+    }
+    if (this.isFastifyError(exception)) {
+      const fastifyError = exception;
+      return {
+        statusCode: fastifyError.statusCode ?? 500,
+        message: fastifyError.message,
+        error: fastifyError.code ?? "Error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        path: path2,
+        ...requestId && {
+          requestId
+        },
+        ...this.includeStack && {
+          stack: exception.stack
+        }
+      };
+    }
+    return {
+      statusCode: 500,
+      message: this.includeStack ? exception.message : "Internal Server Error",
+      error: "Internal Server Error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      path: path2,
+      ...requestId && {
+        requestId
+      },
+      ...this.includeStack && {
+        stack: exception.stack
+      }
+    };
+  }
+  /**
+  * Check if error is a Fastify validation error
+  */
+  isFastifyValidationError(error) {
+    return "validation" in error && Array.isArray(error.validation);
+  }
+  /**
+  * Check if error is a Fastify error with statusCode
+  */
+  isFastifyError(error) {
+    return "statusCode" in error;
+  }
+  /**
+  * Log error to console
+  */
+  logError(exception, method, path2, requestId) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const status = exception instanceof HttpException ? exception.getStatus() : 500;
+    const prefix = status >= 500 ? "\u274C" : "\u26A0\uFE0F";
+    const reqIdStr = requestId ? ` [${requestId}]` : "";
+    console.error(`${prefix} [${timestamp}]${reqIdStr} ${method} ${path2} - ${status} ${exception.message}`);
+    if (status >= 500 && this.includeStack && exception.stack) {
+      console.error(exception.stack);
+    }
+  }
+};
+function createExceptionHandler(filter, customFilters = /* @__PURE__ */ new Map()) {
+  return async (error, request, reply) => {
+    const context = {
+      exception: error,
+      request,
+      reply,
+      path: request.url,
+      method: request.method,
+      requestId: request.id
+    };
+    for (const [ExceptionType, customFilter] of customFilters) {
+      if (error instanceof ExceptionType) {
+        return customFilter.catch(error, context);
+      }
+    }
+    return filter.catch(error, context);
+  };
+}
+__name(createExceptionHandler, "createExceptionHandler");
+
+// src/core/exceptions/catch.decorator.ts
+var import_reflect_metadata10 = require("reflect-metadata");
+var CATCH_METADATA = /* @__PURE__ */ Symbol("catch:metadata");
+function Catch(...exceptions) {
+  return (target) => {
+    const metadata = {
+      exceptions: exceptions.length > 0 ? exceptions : []
+    };
+    Reflect.defineMetadata(CATCH_METADATA, metadata, target);
+  };
+}
+__name(Catch, "Catch");
+function getCatchMetadata(target) {
+  return Reflect.getMetadata(CATCH_METADATA, target);
+}
+__name(getCatchMetadata, "getCatchMetadata");
+
+// src/core/config/env-loader.ts
+var import_dotenv = require("dotenv");
+var import_fs = require("fs");
+var import_path2 = require("path");
+var envLoaded = false;
+function loadEnvFiles() {
+  if (envLoaded) {
+    return;
+  }
+  const env = process.env.NODE_ENV || "development";
+  const cwd = process.cwd();
+  const baseEnvPath = (0, import_path2.resolve)(cwd, ".env");
+  if ((0, import_fs.existsSync)(baseEnvPath)) {
+    (0, import_dotenv.config)({
+      path: baseEnvPath,
+      override: false
+    });
+  }
+  const envSpecificPath = (0, import_path2.resolve)(cwd, `.env.${env}`);
+  if ((0, import_fs.existsSync)(envSpecificPath)) {
+    (0, import_dotenv.config)({
+      path: envSpecificPath,
+      override: true
+    });
+  }
+  envLoaded = true;
+}
+__name(loadEnvFiles, "loadEnvFiles");
+function isEnvLoaded() {
+  return envLoaded;
+}
+__name(isEnvLoaded, "isEnvLoaded");
+function resetEnvLoaded() {
+  envLoaded = false;
+}
+__name(resetEnvLoaded, "resetEnvLoaded");
+
+// src/core/application.ts
+var RiktaFactory = class {
+  static {
+    __name(this, "RiktaFactory");
+  }
+  /**
+  * Create and bootstrap the application
+  * 
+  * .env files are loaded automatically before any initialization,
+  * making environment variables available immediately.
+  * 
+  * @example
+  * ```typescript
+  * // Auto-discovery from current directory (default)
+  * // process.env variables are available immediately after this line
+  * const app = await Rikta.create({ port: 3000 });
+  * 
+  * // Auto-discovery from specific paths
+  * const app = await Rikta.create({
+  *   autowired: ['./src/controllers', './src/services'],
+  *   port: 3000
+  * });
+  * ```
+  */
+  static async create(config = {}) {
+    loadEnvFiles();
+    const silent = config.silent ?? false;
+    if (!silent) console.log("\n\u{1F680} Rikta Framework Starting...\n");
+    const callerDir = getCallerDirectory();
+    let discoveredFiles = [];
+    if (!config.controllers && config.autowired !== false) {
+      const patterns = Array.isArray(config.autowired) && config.autowired.length > 0 ? config.autowired : [
+        "./**"
+      ];
+      discoveredFiles = await discoverModules({
+        patterns,
+        cwd: callerDir,
+        strict: config.strictDiscovery ?? false,
+        onImportError: config.onDiscoveryError
+      });
+    }
+    const app = new RiktaApplicationImpl(config);
+    await app.init(discoveredFiles);
+    return app;
+  }
+};
+var RiktaApplicationImpl = class RiktaApplicationImpl2 {
+  static {
+    __name(this, "RiktaApplicationImpl");
+  }
+  server;
+  container;
+  config;
+  router;
+  events;
+  initializedProviders = [];
+  customExceptionFilters = /* @__PURE__ */ new Map();
+  startTime = Date.now();
+  isListening = false;
+  address = "";
+  constructor(config) {
+    const silent = config.silent ?? false;
+    this.config = {
+      port: config.port ?? DEFAULT_CONFIG.port,
+      host: config.host ?? DEFAULT_CONFIG.host,
+      // If silent mode, disable logger unless explicitly set
+      logger: config.logger ?? (silent ? false : DEFAULT_CONFIG.logger),
+      prefix: config.prefix ?? DEFAULT_CONFIG.prefix,
+      silent,
+      controllers: config.controllers,
+      providers: config.providers,
+      exceptionFilter: config.exceptionFilter,
+      exceptionFilters: config.exceptionFilters
+    };
+    this.server = (0, import_fastify.default)({
+      logger: this.config.logger
+    });
+    this.container = Container.getInstance();
+    this.router = new Router(this.server, this.container, this.config.prefix);
+    this.events = new EventBus();
+    this.container.registerInstance(EventBus, this.events);
+    this.setupExceptionHandler();
+  }
+  /**
+  * Setup global exception handler
+  */
+  setupExceptionHandler() {
+    const silent = this.config.silent ?? false;
+    const globalFilter = new GlobalExceptionFilter({
+      includeStack: this.config.exceptionFilter?.includeStack,
+      logErrors: this.config.exceptionFilter?.logErrors ?? (silent ? false : true)
+    });
+    const customFilters = this.config.exceptionFilters ?? [];
+    for (const FilterClass of customFilters) {
+      const metadata = getCatchMetadata(FilterClass);
+      const filterInstance = this.container.resolve(FilterClass);
+      if (metadata && metadata.exceptions.length > 0) {
+        for (const ExceptionType of metadata.exceptions) {
+          this.customExceptionFilters.set(ExceptionType, filterInstance);
+        }
+      } else {
+        this.customExceptionFilters.set(Error, filterInstance);
+      }
+    }
+    this.server.setErrorHandler(createExceptionHandler(globalFilter, this.customExceptionFilters));
+  }
+  /**
+  * Initialize the application
+  */
+  async init(discoveredFiles = []) {
+    await this.events.emit("app:discovery", {
+      files: discoveredFiles
+    });
+    await this.processConfigProviders();
+    await this.processCustomProviders();
+    await this.events.emit("app:providers", {
+      count: registry.getCustomProviders().length
+    });
+    const providers = this.getSortedProviders();
+    const additionalProviders = this.config.providers ?? [];
+    for (const provider of additionalProviders) {
+      this.registerProvider(provider);
+    }
+    for (const { target, priority } of providers) {
+      await this.initializeProvider(target, priority);
+    }
+    const controllers = this.config.controllers ?? registry.getControllers();
+    if (!this.config.silent) console.log("\u{1F4E1} Registering routes:");
+    for (const controller of controllers) {
+      this.router.registerController(controller, this.config.silent);
+    }
+    await this.events.emit("app:routes", {
+      count: controllers.length
+    });
+    await this.callHook("onApplicationBootstrap");
+    await this.events.emit("app:bootstrap", {
+      providerCount: this.initializedProviders.length
+    });
+    if (!this.config.silent) console.log("\n\u2705 Rikta is ready\n");
+  }
+  /**
+  * Process all config providers and register them in the container
+  */
+  async processConfigProviders() {
+    const configProviders = registry.getConfigProviderRegistrations();
+    if (configProviders.length === 0) return;
+    for (const { token, providerClass } of configProviders) {
+      this.container.registerProvider({
+        provide: token,
+        useClass: providerClass
+      });
+    }
+  }
+  /**
+  * Process all @Provider decorated classes
+  */
+  async processCustomProviders() {
+    const customProviders = registry.getCustomProviders();
+    if (customProviders.length === 0) return;
+    for (const ProviderClass of customProviders) {
+      const metadata = Reflect.getMetadata(PROVIDER_METADATA, ProviderClass);
+      if (!metadata) continue;
+      const providerInstance = this.container.resolve(ProviderClass);
+      const value = await providerInstance.provide();
+      this.container.registerValue(metadata.token, value);
+    }
+  }
+  /**
+  * Get providers sorted by priority (higher = first)
+  */
+  getSortedProviders() {
+    const providers = registry.getProviders();
+    return providers.map((target) => ({
+      target,
+      priority: this.getProviderPriority(target)
+    })).sort((a, b) => b.priority - a.priority);
+  }
+  /**
+  * Get priority from @Injectable() metadata
+  */
+  getProviderPriority(target) {
+    const options = Reflect.getMetadata(INJECTABLE_METADATA, target);
+    return options?.priority ?? 0;
+  }
+  /**
+  * Initialize a single provider
+  */
+  async initializeProvider(target, priority) {
+    const instance = this.container.resolve(target);
+    const name = target.name;
+    this.initializedProviders.push({
+      instance,
+      priority,
+      name
+    });
+    if (this.hasHook(instance, "onProviderInit")) {
+      await instance.onProviderInit();
+    }
+    await this.events.emit("provider:init", {
+      provider: target,
+      name,
+      priority
+    });
+    this.registerEventListeners(target, instance);
+  }
+  /**
+  * Register @On() decorated methods as event listeners
+  * Tracks listeners by provider name for cleanup during shutdown
+  */
+  registerEventListeners(target, instance) {
+    const metadata = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
+    for (const { event, methodName } of metadata) {
+      const method = instance[methodName];
+      if (typeof method === "function") {
+        this.events.on(event, method.bind(instance), target.name);
+      }
+    }
+  }
+  /**
+  * Register a provider in the container
+  */
+  registerProvider(provider) {
+    const instance = this.container.resolve(provider);
+    const priority = this.getProviderPriority(provider);
+    this.initializedProviders.push({
+      instance,
+      priority,
+      name: provider.name
+    });
+  }
+  /**
+  * Call a lifecycle hook on all initialized providers
+  */
+  async callHook(hookName) {
+    for (const { instance } of this.initializedProviders) {
+      if (this.hasHook(instance, hookName)) {
+        await instance[hookName]();
+      }
+    }
+  }
+  /**
+  * Check if an instance has a lifecycle hook
+  */
+  hasHook(instance, hookName) {
+    return instance !== null && typeof instance === "object" && hookName in instance && typeof instance[hookName] === "function";
+  }
+  /**
+  * Start listening for requests
+  */
+  async listen() {
+    if (this.isListening) {
+      return this.address;
+    }
+    this.address = await this.server.listen({
+      port: this.config.port,
+      host: this.config.host
+    });
+    this.isListening = true;
+    for (const { instance } of this.initializedProviders) {
+      if (this.hasHook(instance, "onApplicationListen")) {
+        await instance.onApplicationListen(this.address);
+      }
+    }
+    await this.events.emit("app:listen", {
+      address: this.address,
+      port: this.config.port
+    });
+    return this.address;
+  }
+  /**
+  * Close the application
+  */
+  async close(signal) {
+    await this.events.emit("app:shutdown", {
+      signal
+    });
+    const reversed = [
+      ...this.initializedProviders
+    ].reverse();
+    for (const { instance, name } of reversed) {
+      if (this.hasHook(instance, "onApplicationShutdown")) {
+        await instance.onApplicationShutdown(signal);
+      }
+      if (this.hasHook(instance, "onProviderDestroy")) {
+        await instance.onProviderDestroy();
+      }
+      this.events.removeByOwner(name);
+    }
+    await this.server.close();
+    this.isListening = false;
+    await this.events.emit("app:destroy", {
+      uptime: Date.now() - this.startTime
+    });
+    this.events.clear();
+    if (!this.config.silent) console.log("\n\u{1F44B} Application closed\n");
+  }
+  /**
+  * Get the server URL
+  */
+  getUrl() {
+    return this.address;
+  }
+  /**
+  * Get the EventBus instance
+  */
+  getEventBus() {
+    return this.events;
+  }
+  /**
+  * Get the DI Container instance
+  */
+  getContainer() {
+    return this.container;
+  }
+  /**
+  * Get the Router instance
+  * Useful for accessing router cache management methods
+  */
+  getRouter() {
+    return this.router;
+  }
+  /**
+  * Clear all router caches (guards and middleware)
+  * Useful for testing or hot-reload scenarios
+  * 
+  * @example
+  * ```typescript
+  * // In tests
+  * afterEach(() => {
+  *   app.clearRouterCaches();
+  * });
+  * ```
+  */
+  clearRouterCaches() {
+    this.router.clearAllCaches();
+  }
+};
+
+// src/core/decorators/controller.decorator.ts
+var import_reflect_metadata12 = require("reflect-metadata");
+function Controller(prefixOrOptions) {
+  return (target) => {
+    const prefix = typeof prefixOrOptions === "string" ? prefixOrOptions : prefixOrOptions?.prefix ?? "";
+    const normalizedPrefix = prefix ? prefix.startsWith("/") ? prefix : `/${prefix}` : "";
+    Reflect.defineMetadata(CONTROLLER_METADATA, {
+      prefix: normalizedPrefix
+    }, target);
+    Reflect.defineMetadata(INJECTABLE_METADATA, {
+      scope: "singleton"
+    }, target);
+    container.register(target, {
+      scope: "singleton"
+    });
+    registry.registerController(target);
+  };
+}
+__name(Controller, "Controller");
+
+// src/core/decorators/route.decorator.ts
+var import_reflect_metadata13 = require("reflect-metadata");
+function createRouteDecorator(method) {
+  return (path2 = "") => {
+    return (target, propertyKey, descriptor) => {
+      const normalizedPath = path2.startsWith("/") ? path2 : `/${path2}`;
+      const routes = Reflect.getMetadata(ROUTES_METADATA, target.constructor) ?? [];
+      routes.push({
+        method,
+        path: normalizedPath === "/" ? "" : normalizedPath,
+        handlerName: propertyKey
+      });
+      Reflect.defineMetadata(ROUTES_METADATA, routes, target.constructor);
+      return descriptor;
+    };
+  };
+}
+__name(createRouteDecorator, "createRouteDecorator");
+var Get = createRouteDecorator("GET");
+var Post = createRouteDecorator("POST");
+var Put = createRouteDecorator("PUT");
+var Patch = createRouteDecorator("PATCH");
+var Delete = createRouteDecorator("DELETE");
+var Options = createRouteDecorator("OPTIONS");
+var Head = createRouteDecorator("HEAD");
+function HttpCode(statusCode) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(HTTP_CODE_METADATA, statusCode, target.constructor, propertyKey);
+    return descriptor;
+  };
+}
+__name(HttpCode, "HttpCode");
+
+// src/core/decorators/param.decorator.ts
+var import_reflect_metadata14 = require("reflect-metadata");
+function isZodType(value) {
+  return value !== null && typeof value === "object" && ("_zod" in value || "_def" in value) && "safeParse" in value && typeof value.safeParse === "function";
+}
+__name(isZodType, "isZodType");
+function createParamDecorator2(type) {
+  function decorator(keyOrSchema) {
+    return (target, propertyKey, parameterIndex) => {
+      if (propertyKey === void 0) return;
+      const existingParams = Reflect.getMetadata(PARAM_METADATA, target.constructor, propertyKey) ?? [];
+      const isSchema = isZodType(keyOrSchema);
+      const metadata = {
+        index: parameterIndex,
+        type,
+        key: isSchema ? void 0 : keyOrSchema,
+        zodSchema: isSchema ? keyOrSchema : void 0
+      };
+      existingParams.push(metadata);
+      Reflect.defineMetadata(PARAM_METADATA, existingParams, target.constructor, propertyKey);
+    };
+  }
+  __name(decorator, "decorator");
+  return decorator;
+}
+__name(createParamDecorator2, "createParamDecorator");
+var Body = createParamDecorator2(ParamType.BODY);
+var Query = createParamDecorator2(ParamType.QUERY);
+var Param = createParamDecorator2(ParamType.PARAM);
+var Headers = createParamDecorator2(ParamType.HEADERS);
+var Req = createParamDecorator2(ParamType.REQUEST);
+var Request = Req;
+var Res = createParamDecorator2(ParamType.REPLY);
+var Reply = Res;
+var Ctx = createParamDecorator2(ParamType.CONTEXT);
+var Context = Ctx;
+
+// src/core/decorators/autowired.decorator.ts
+var import_reflect_metadata15 = require("reflect-metadata");
+function Autowired(token, name) {
+  return (target, propertyKey, parameterIndex) => {
+    if (typeof parameterIndex === "number") {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target) ?? [];
+      const inferredType = paramTypes[parameterIndex];
+      const resolvedToken = token ?? inferredType;
+      if (!resolvedToken) {
+        throw new Error(`@Autowired() on constructor parameter ${parameterIndex} of ${target.name} could not infer type. Please provide a token explicitly.`);
+      }
+      const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
+      existingInjects.push({
+        token: resolvedToken,
+        index: parameterIndex,
+        name
+      });
+      Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
+    } else if (propertyKey !== void 0) {
+      const inferredType = Reflect.getMetadata("design:type", target, propertyKey);
+      const resolvedToken = token ?? inferredType;
+      if (!resolvedToken) {
+        throw new Error(`@Autowired() on ${target.constructor.name}.${String(propertyKey)} could not infer type. Please provide a token explicitly.`);
+      }
+      const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
+      existingAutowires.push({
+        token: resolvedToken,
+        propertyKey: String(propertyKey),
+        name
+      });
+      Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
+    }
+  };
+}
+__name(Autowired, "Autowired");
+function Optional() {
+  return (target, propertyKey, parameterIndex) => {
+    if (typeof parameterIndex === "number") {
+      const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
+      let meta = existingInjects.find((m) => m.index === parameterIndex);
+      if (meta) {
+        meta.optional = true;
+      } else {
+        const paramTypes = Reflect.getMetadata("design:paramtypes", target) ?? [];
+        const paramType = paramTypes[parameterIndex];
+        if (paramType) {
+          existingInjects.push({
+            token: paramType,
+            index: parameterIndex,
+            optional: true
+          });
+        }
+      }
+      Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
+    } else if (propertyKey !== void 0) {
+      const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
+      let meta = existingAutowires.find((m) => m.propertyKey === String(propertyKey));
+      if (meta) {
+        meta.optional = true;
+      } else {
+        const propType = Reflect.getMetadata("design:type", target, propertyKey);
+        if (propType) {
+          existingAutowires.push({
+            token: propType,
+            propertyKey: String(propertyKey),
+            optional: true
+          });
+        }
+      }
+      Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
+    }
+  };
+}
+__name(Optional, "Optional");
+
+// src/core/decorators/provider.decorator.ts
+var import_reflect_metadata16 = require("reflect-metadata");
+function generateTokenFromClassName(className) {
+  let tokenName = className.replace(/Provider$/, "");
+  tokenName = tokenName.replace(/([A-Z])/g, "_$1").toUpperCase().replace(/^_/, "");
+  if (!tokenName.endsWith("_CONFIG") && tokenName !== "CONFIG") {
+    tokenName = `${tokenName}_CONFIG`;
+  }
+  return tokenName;
+}
+__name(generateTokenFromClassName, "generateTokenFromClassName");
+function Provider(token) {
+  return (target) => {
+    const className = target.name;
+    const isConfigProvider2 = typeof target.prototype.schema === "function";
+    if (isConfigProvider2) {
+      let configToken;
+      if (typeof token === "string") {
+        if (token.trim() === "") {
+          throw new Error(`@Provider: Config provider "${className}" token must be a non-empty string.`);
+        }
+        configToken = token;
+      } else if (token === void 0) {
+        configToken = generateTokenFromClassName(className);
+      } else {
+        throw new Error(`@Provider: Config provider "${className}" requires a string token or no token for auto-generation.`);
+      }
+      if (configToken !== configToken.toUpperCase()) {
+        throw new Error(`@Provider: Token "${configToken}" for config provider "${className}" must be UPPERCASE. Use "${configToken.toUpperCase()}" instead.`);
+      }
+      const configMetadata = {
+        token: configToken
+      };
+      Reflect.defineMetadata(CONFIG_PROVIDER_METADATA, configMetadata, target);
+      registry.registerConfigProvider(configToken, target);
+    } else {
+      if (token === void 0) {
+        throw new Error(`@Provider: Custom provider "${className}" requires a token parameter.`);
+      }
+      const metadata = {
+        token
+      };
+      Reflect.defineMetadata(PROVIDER_METADATA, metadata, target);
+      registry.registerCustomProvider(target);
+    }
+  };
+}
+__name(Provider, "Provider");
+function getConfigProviderMetadata(target) {
+  return Reflect.getMetadata(CONFIG_PROVIDER_METADATA, target);
+}
+__name(getConfigProviderMetadata, "getConfigProviderMetadata");
+function isConfigProvider(target) {
+  return Reflect.hasMetadata(CONFIG_PROVIDER_METADATA, target);
+}
+__name(isConfigProvider, "isConfigProvider");
+
+// src/core/decorators/config-property.decorator.ts
+var import_reflect_metadata17 = require("reflect-metadata");
+var propertyNameCache = /* @__PURE__ */ new Map();
+function toUpperSnakeCase(propertyName) {
+  if (propertyNameCache.has(propertyName)) {
+    return propertyNameCache.get(propertyName);
+  }
+  const envKey = propertyName.replace(/([A-Z])/g, "_$1").toUpperCase().replace(/^_/, "");
+  propertyNameCache.set(propertyName, envKey);
+  return envKey;
+}
+__name(toUpperSnakeCase, "toUpperSnakeCase");
+function ConfigProperty(envKey) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "symbol") {
+      throw new Error(`@ConfigProperty: Symbol properties are not supported. Property "${String(propertyKey)}" must be a string.`);
+    }
+    const finalEnvKey = envKey ?? toUpperSnakeCase(propertyKey);
+    if (!finalEnvKey || typeof finalEnvKey !== "string") {
+      throw new Error(`@ConfigProperty: Invalid env key for property "${propertyKey}". Env key must be a non-empty string.`);
+    }
+    if (finalEnvKey !== finalEnvKey.toUpperCase()) {
+      throw new Error(`@ConfigProperty: Env key "${finalEnvKey}" for property "${propertyKey}" must be UPPERCASE. Use "${finalEnvKey.toUpperCase()}" instead.`);
+    }
+    const constructor = target.constructor;
+    const existingMappings = Reflect.getMetadata(CONFIG_PROPERTY_METADATA, constructor) || [];
+    const duplicate = existingMappings.find((m) => m.propertyKey === propertyKey);
+    if (duplicate) {
+      throw new Error(`@ConfigProperty: Property "${propertyKey}" on class "${constructor.name}" is already decorated. Remove the duplicate @ConfigProperty decorator.`);
+    }
+    const duplicateEnvKey = existingMappings.find((m) => m.envKey === finalEnvKey);
+    if (duplicateEnvKey) {
+      throw new Error(`@ConfigProperty: Env key "${finalEnvKey}" is already mapped to property "${duplicateEnvKey.propertyKey}" on class "${constructor.name}". Each env key can only be mapped to one property.`);
+    }
+    const newMapping = {
+      propertyKey,
+      envKey: finalEnvKey
+    };
+    const updatedMappings = [
+      ...existingMappings,
+      newMapping
+    ];
+    Reflect.defineMetadata(CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
+  };
+}
+__name(ConfigProperty, "ConfigProperty");
+function getConfigPropertyMappings(target) {
+  return Reflect.getMetadata(CONFIG_PROPERTY_METADATA, target) || [];
+}
+__name(getConfigPropertyMappings, "getConfigPropertyMappings");
+function hasConfigProperties(target) {
+  const mappings = getConfigPropertyMappings(target);
+  return mappings.length > 0;
+}
+__name(hasConfigProperties, "hasConfigProperties");
+function clearPropertyNameCache() {
+  propertyNameCache.clear();
+}
+__name(clearPropertyNameCache, "clearPropertyNameCache");
+
+// src/core/decorators/apply-decorators.ts
+var import_reflect_metadata18 = require("reflect-metadata");
+function applyDecorators(...decorators) {
+  return (target, propertyKey, descriptor) => {
+    for (const decorator of decorators.reverse()) {
+      if (descriptor) {
+        const result = decorator(target, propertyKey, descriptor);
+        if (result) {
+          descriptor = result;
+        }
+      } else if (propertyKey !== void 0) {
+        decorator(target, propertyKey);
+      } else {
+        const result = decorator(target);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    if (descriptor) {
+      return descriptor;
+    }
+  };
+}
+__name(applyDecorators, "applyDecorators");
+function SetMetadata(key, value) {
+  const decoratorFactory = /* @__PURE__ */ __name((target, propertyKey, descriptor) => {
+    if (descriptor) {
+      Reflect.defineMetadata(key, value, target.constructor, propertyKey);
+    } else {
+      Reflect.defineMetadata(key, value, target);
+    }
+  }, "decoratorFactory");
+  return decoratorFactory;
+}
+__name(SetMetadata, "SetMetadata");
+
+// src/core/middleware/middleware.decorator.ts
+var import_reflect_metadata19 = require("reflect-metadata");
+function Middleware() {
+  return (target) => {
+    Reflect.defineMetadata("middleware", true, target);
+    Reflect.defineMetadata("injectable", true, target);
+  };
+}
+__name(Middleware, "Middleware");
+
+// src/core/config/abstract-config-provider.ts
+var import_zod = require("zod");
+var ConfigValidationException = class extends Error {
+  static {
+    __name(this, "ConfigValidationException");
+  }
+  errors;
+  constructor(errors, providerName) {
+    const errorMessages = errors.issues.map((err) => `  - ${err.path.join(".")}: ${err.message}`).join("\n");
+    super(`Configuration validation failed for ${providerName}:
+${errorMessages}
+
+Please check your .env file and ensure all required variables are set correctly.`), this.errors = errors;
+    this.name = "ConfigValidationException";
+  }
+};
+var AbstractConfigProvider = class {
+  static {
+    __name(this, "AbstractConfigProvider");
+  }
+  /**
+  * Cache for validated configuration
+  * Frozen to prevent accidental mutations
+  */
+  _cache;
+  /**
+  * Constructor ensures .env files are loaded (for standalone usage)
+  * 
+  * Note: When using Rikta.create(), .env files are loaded automatically
+  * during bootstrap, so this is a safety measure for standalone usage.
+  */
+  constructor() {
+    loadEnvFiles();
+  }
+  /**
+  * Validate and cache the configuration
+  * 
+  * This method runs the Zod schema validation against process.env
+  * and caches the result. Subsequent calls return the cached value.
+  * 
+  * @returns The validated and frozen configuration object
+  * @throws {ConfigValidationException} If validation fails
+  * 
+  * @private
+  */
+  validateAndCache() {
+    if (this._cache) {
+      return this._cache;
+    }
+    try {
+      const schema = this.schema();
+      const validated = schema.parse(process.env);
+      this._cache = Object.freeze(validated);
+      return this._cache;
+    } catch (error) {
+      if (error instanceof import_zod.z.ZodError) {
+        throw new ConfigValidationException(error, this.constructor.name);
+      }
+      throw error;
+    }
+  }
+  /**
+  * Populate decorated properties with validated values
+  * 
+  * This method reads the @ConfigProperty metadata and assigns
+  * the corresponding validated environment values to class properties.
+  * 
+  * Must be called in the child class constructor after super().
+  * 
+  * @throws {ConfigValidationException} If validation fails
+  * 
+  * @example
+  * ```typescript
+  * constructor() {
+  *   super();
+  *   this.populate(); // Must call this!
+  * }
+  * ```
+  */
+  populate() {
+    const config = this.validateAndCache();
+    const mappings = getConfigPropertyMappings(this.constructor);
+    for (const mapping of mappings) {
+      const value = config[mapping.envKey];
+      this[mapping.propertyKey] = value;
+    }
+  }
+  /**
+  * Get the raw validated configuration object
+  * 
+  * This is useful for accessing config values that aren't mapped
+  * to properties, or for passing the entire config to other services.
+  * 
+  * @returns The validated and frozen configuration object
+  * 
+  * @example
+  * ```typescript
+  * const config = this.getConfig();
+  * console.log('All env vars:', config);
+  * ```
+  */
+  getConfig() {
+    return this.validateAndCache();
+  }
+  /**
+  * Get a specific configuration value by key
+  * 
+  * @param key - The environment variable name
+  * @returns The validated value, or undefined if not found
+  * 
+  * @example
+  * ```typescript
+  * const port = this.get<number>('PORT');
+  * const apiKey = this.get<string>('API_KEY');
+  * ```
+  */
+  get(key) {
+    const config = this.validateAndCache();
+    return config[key];
+  }
+};
+
+// src/core/metadata.ts
+var import_reflect_metadata20 = require("reflect-metadata");
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(CONTROLLER_METADATA, target);
+}
+__name(getControllerMetadata, "getControllerMetadata");
+function isController(target) {
+  return Reflect.hasMetadata(CONTROLLER_METADATA, target);
+}
+__name(isController, "isController");
+function getControllerPath(target) {
+  const meta = getControllerMetadata(target);
+  return meta?.prefix ?? "";
+}
+__name(getControllerPath, "getControllerPath");
+function getRoutes(target) {
+  return Reflect.getMetadata(ROUTES_METADATA, target) || [];
+}
+__name(getRoutes, "getRoutes");
+function hasRoutes(target) {
+  const routes = getRoutes(target);
+  return routes.length > 0;
+}
+__name(hasRoutes, "hasRoutes");
+function getParamMetadata(target, methodName) {
+  return Reflect.getMetadata(PARAM_METADATA, target.prototype, methodName) || [];
+}
+__name(getParamMetadata, "getParamMetadata");
+function getParamMetadataByIndex(target, methodName, paramIndex) {
+  const params = getParamMetadata(target, methodName);
+  return params.find((p) => p.index === paramIndex);
+}
+__name(getParamMetadataByIndex, "getParamMetadataByIndex");
+function getHttpCode(target, methodName) {
+  return Reflect.getMetadata(HTTP_CODE_METADATA, target.prototype, methodName);
+}
+__name(getHttpCode, "getHttpCode");
+function getGuards(target, methodName) {
+  if (methodName) {
+    const methodGuards = Reflect.getMetadata(GUARDS_METADATA, target.prototype, methodName) || [];
+    const controllerGuards = Reflect.getMetadata(GUARDS_METADATA, target) || [];
+    return [
+      ...controllerGuards,
+      ...methodGuards
+    ];
+  }
+  return Reflect.getMetadata(GUARDS_METADATA, target) || [];
+}
+__name(getGuards, "getGuards");
+function getZodSchema(target, methodName) {
+  return Reflect.getMetadata(ZOD_SCHEMA_METADATA, target.prototype, methodName);
+}
+__name(getZodSchema, "getZodSchema");
+function getClassMetadata(metadataKey, target) {
+  return Reflect.getMetadata(metadataKey, target);
+}
+__name(getClassMetadata, "getClassMetadata");
+function getMethodMetadata(metadataKey, target, methodName) {
+  return Reflect.getMetadata(metadataKey, target.prototype, methodName);
+}
+__name(getMethodMetadata, "getMethodMetadata");
+function hasClassMetadata(metadataKey, target) {
+  return Reflect.hasMetadata(metadataKey, target);
+}
+__name(hasClassMetadata, "hasClassMetadata");
+function hasMethodMetadata(metadataKey, target, methodName) {
+  return Reflect.hasMetadata(metadataKey, target.prototype, methodName);
+}
+__name(hasMethodMetadata, "hasMethodMetadata");
+function getMethodsWithMetadata(metadataKey, target) {
+  const methods = [];
+  const prototype = target.prototype;
+  const propertyNames = Object.getOwnPropertyNames(prototype);
+  const propertySymbols = Object.getOwnPropertySymbols(prototype);
+  for (const name of [
+    ...propertyNames,
+    ...propertySymbols
+  ]) {
+    if (name !== "constructor" && Reflect.hasMetadata(metadataKey, prototype, name)) {
+      methods.push(name);
+    }
+  }
+  return methods;
+}
+__name(getMethodsWithMetadata, "getMethodsWithMetadata");
+
+// src/core/profiler/performance-profiler.ts
+var PerformanceProfiler = class {
+  static {
+    __name(this, "PerformanceProfiler");
+  }
+  enabled = true;
+  eventBus;
+  listeners = [];
+  bootstrapMetrics = {};
+  constructor(options) {
+    this.enabled = options?.enabled ?? true;
+    this.eventBus = options?.eventBus;
+  }
+  /**
+  * Enable or disable profiling
+  */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+  * Check if profiling is enabled
+  */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+  * Start a timer for measuring an operation
+  * 
+  * @param name - Name of the operation
+  * @returns A function to call when the operation completes
+  */
+  startTimer(name) {
+    if (!this.enabled) {
+      return () => null;
+    }
+    const startTime = performance.now();
+    const startTimestamp = Date.now();
+    return (metadata) => {
+      const duration = performance.now() - startTime;
+      const metric = {
+        name,
+        duration,
+        startTime: startTimestamp,
+        metadata
+      };
+      this.emitMetric(metric);
+      return metric;
+    };
+  }
+  /**
+  * Measure the execution time of a function
+  * 
+  * @param name - Name of the operation
+  * @param fn - Function to measure
+  * @returns The result of the function
+  */
+  async measure(name, fn) {
+    const end = this.startTimer(name);
+    try {
+      const result = await fn();
+      end();
+      return result;
+    } catch (error) {
+      end({
+        error: true
+      });
+      throw error;
+    }
+  }
+  /**
+  * Record a route request metric
+  */
+  recordRouteMetric(metric) {
+    if (!this.enabled) return;
+    this.emitMetric(metric);
+    this.eventBus?.emit("profiler:route", metric);
+  }
+  /**
+  * Record bootstrap phase timing
+  */
+  recordBootstrapPhase(phase, duration) {
+    this.bootstrapMetrics[phase] = duration;
+  }
+  /**
+  * Get bootstrap metrics
+  */
+  getBootstrapMetrics() {
+    return {
+      ...this.bootstrapMetrics
+    };
+  }
+  /**
+  * Subscribe to metric events
+  * 
+  * @param listener - Callback for each metric
+  * @returns Unsubscribe function
+  */
+  onMetric(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index !== -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+  * Emit a metric to all listeners
+  */
+  emitMetric(metric) {
+    for (const listener of this.listeners) {
+      try {
+        listener(metric);
+      } catch {
+      }
+    }
+    this.eventBus?.emit("profiler:metric", metric);
+  }
+  /**
+  * Create a timer that automatically logs to console
+  */
+  createConsoleTimer(prefix = "[Rikta]") {
+    return (name) => {
+      const end = this.startTimer(name);
+      return (metadata) => {
+        const metric = end(metadata);
+        if (metric) {
+          console.log(`${prefix} ${metric.name}: ${metric.duration.toFixed(2)}ms`);
+        }
+      };
+    };
+  }
+};
+var profiler = new PerformanceProfiler();
+function setGlobalProfiler(newProfiler) {
+  profiler = newProfiler;
+}
+__name(setGlobalProfiler, "setGlobalProfiler");
+function getGlobalProfiler() {
+  return profiler;
+}
+__name(getGlobalProfiler, "getGlobalProfiler");
+
+// src/core/index.ts
+var import_zod2 = require("zod");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTOWIRED_METADATA,
+  AbstractClass,
+  AbstractConfigProvider,
+  Autowired,
+  BadGatewayException,
+  BadRequestException,
+  Body,
+  CATCH_METADATA,
+  CONFIG_PROPERTY_METADATA,
+  CONFIG_PROVIDER_METADATA,
+  CONTROLLER_METADATA,
+  CUSTOM_PARAM_METADATA,
+  Catch,
+  ConfigProperty,
+  ConfigProviderAlreadyRegisteredException,
+  ConfigProviderInstantiationException,
+  ConfigProviderNotFoundException,
+  ConfigValidationException,
+  ConflictException,
+  Container,
+  Context,
+  Controller,
+  Ctx,
+  DEFAULT_CONFIG,
+  Delete,
+  DiscoveryException,
+  EventBus,
+  ExecutionContextImpl,
+  ForbiddenException,
+  GUARDS_METADATA,
+  GatewayTimeoutException,
+  Get,
+  GlobalExceptionFilter,
+  GoneException,
+  HEADERS_METADATA,
+  HTTP_CODE_METADATA,
+  Head,
+  Headers,
+  HttpCode,
+  HttpException,
+  IMPLEMENTS_METADATA,
+  INJECTABLE_METADATA,
+  INJECT_METADATA,
+  INTERCEPTORS_METADATA,
+  Implements,
+  Injectable,
+  InjectionToken,
+  InternalServerErrorException,
+  MIDDLEWARE_METADATA,
+  MethodNotAllowedException,
+  Middleware,
+  Named,
+  NotAcceptableException,
+  NotFoundException,
+  NotImplementedException,
+  ON_EVENT_METADATA,
+  On,
+  Optional,
+  Options,
+  PARAM_METADATA,
+  PRIMARY_METADATA,
+  PROVIDER_METADATA,
+  Param,
+  ParamType,
+  Patch,
+  PayloadTooLargeException,
+  PerformanceProfiler,
+  Post,
+  Primary,
+  Provider,
+  Put,
+  Query,
+  ROUTES_METADATA,
+  Registry,
+  Reply,
+  Req,
+  Request,
+  RequestScopeStorage,
+  RequestTimeoutException,
+  Res,
+  Rikta,
+  RiktaFactory,
+  Router,
+  ServiceUnavailableException,
+  SetMetadata,
+  TooManyRequestsException,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  UnsupportedMediaTypeException,
+  UseGuards,
+  UseInterceptors,
+  UseMiddleware,
+  ValidationException,
+  ZOD_SCHEMA_METADATA,
+  applyDecorators,
+  clearPropertyNameCache,
+  container,
+  createExceptionHandler,
+  createParamDecorator,
+  discoverModules,
+  extendsFrom,
+  getCallerDirectory,
+  getCatchMetadata,
+  getClassMetadata,
+  getConfigPropertyMappings,
+  getConfigProviderMetadata,
+  getControllerMetadata,
+  getControllerPath,
+  getCustomParamMetadata,
+  getGlobalProfiler,
+  getGuards,
+  getGuardsMetadata,
+  getHttpCode,
+  getImplementedAbstract,
+  getInterceptorsMetadata,
+  getMethodMetadata,
+  getMethodsWithMetadata,
+  getMiddlewareMetadata,
+  getMiddlewaresMetadata,
+  getParamMetadata,
+  getParamMetadataByIndex,
+  getRoutes,
+  getZodSchema,
+  hasClassMetadata,
+  hasConfigProperties,
+  hasMethodMetadata,
+  hasRoutes,
+  isAbstractClass,
+  isConfigProvider,
+  isController,
+  isEnvLoaded,
+  isPrimaryImplementation,
+  loadEnvFiles,
+  markAsAbstract,
+  profiler,
+  registry,
+  requestScopeStorage,
+  resetEnvLoaded,
+  setGlobalProfiler,
+  setImplementsMetadata,
+  setPrimaryMetadata,
+  z
+});
+//# sourceMappingURL=index.cjs.map