node-honest 0.0.7 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2185 @@
+'use strict';
+
+require('reflect-metadata');
+var hono = require('hono');
+var httpException = require('hono/http-exception');
+var html = require('hono/html');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/application/startup-guide.ts
+function createStartupGuideHints(errorMessage) {
+  const hints = /* @__PURE__ */ new Set();
+  hints.add("Check module wiring: root module imports, controllers, and services should be registered correctly.");
+  if (errorMessage.includes("not decorated with @Controller()")) {
+    hints.add("Add @Controller() to the class or remove it from module.controllers.");
+  }
+  if (errorMessage.includes("has no route handlers")) {
+    hints.add("Add at least one HTTP method decorator such as @Get() or @Post() in the controller.");
+  }
+  if (errorMessage.includes("not decorated with @Service()")) {
+    hints.add("Add @Service() to injectable classes used in constructor dependencies.");
+  }
+  if (errorMessage.includes("constructor metadata is missing") || errorMessage.includes("reflect-metadata")) {
+    hints.add("Import 'reflect-metadata' in your entry file and enable 'emitDecoratorMetadata' in tsconfig.");
+  }
+  if (errorMessage.includes("Strict mode: no routes were registered")) {
+    hints.add("Disable strict.requireRoutes for empty modules, or add a controller with at least one route.");
+  }
+  return [
+    ...hints
+  ];
+}
+__name(createStartupGuideHints, "createStartupGuideHints");
+function emitStartupGuide(logger, startupGuide, error, rootModule) {
+  if (!startupGuide) {
+    return;
+  }
+  const verbose = typeof startupGuide === "object" && Boolean(startupGuide.verbose);
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const hints = createStartupGuideHints(errorMessage);
+  logger.emit({
+    level: "warn",
+    category: "startup",
+    message: "Startup guide",
+    details: {
+      rootModule: rootModule.name,
+      errorMessage,
+      hints,
+      verbose
+    }
+  });
+  if (verbose) {
+    logger.emit({
+      level: "warn",
+      category: "startup",
+      message: "Startup guide (verbose)",
+      details: {
+        steps: [
+          "Verify decorators are present for controllers/services used by DI and routing.",
+          "Ensure 'reflect-metadata' is imported once at entry and 'emitDecoratorMetadata' is enabled.",
+          "Enable debug.startup for extra startup diagnostics and timing details."
+        ]
+      }
+    });
+  }
+}
+__name(emitStartupGuide, "emitStartupGuide");
+
+// src/utils/common.util.ts
+var isUndefined = /* @__PURE__ */ __name((obj) => typeof obj === "undefined", "isUndefined");
+var isNil = /* @__PURE__ */ __name((val) => val === null || typeof val === "undefined", "isNil");
+var isObject = /* @__PURE__ */ __name((val) => val !== null && typeof val === "object", "isObject");
+var isPlainObject = /* @__PURE__ */ __name((val) => {
+  if (!isObject(val)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(val);
+  if (proto === null) {
+    return true;
+  }
+  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
+}, "isPlainObject");
+var isFunction = /* @__PURE__ */ __name((val) => typeof val === "function", "isFunction");
+var isString = /* @__PURE__ */ __name((val) => typeof val === "string", "isString");
+var isNumber = /* @__PURE__ */ __name((val) => typeof val === "number", "isNumber");
+var isEmpty = /* @__PURE__ */ __name((array) => array.length === 0, "isEmpty");
+var isSymbol = /* @__PURE__ */ __name((val) => typeof val === "symbol", "isSymbol");
+var addLeadingSlash = /* @__PURE__ */ __name((path) => typeof path === "string" ? path.charAt(0) !== "/" ? "/" + path : path : "", "addLeadingSlash");
+var normalizePath = /* @__PURE__ */ __name((path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/", "normalizePath");
+var stripEndSlash = /* @__PURE__ */ __name((path) => path.endsWith("/") ? path.slice(0, -1) : path, "stripEndSlash");
+var isConstructor = /* @__PURE__ */ __name((val) => {
+  return isFunction(val) && !isNil(val.prototype) && !isFunction(val.prototype) && Object.getOwnPropertyNames(val.prototype).length >= 1;
+}, "isConstructor");
+
+// src/application/plugin-entries.ts
+var DEFAULT_PLUGIN_NAME = "AnonymousPlugin";
+function resolvePlugin(pluginType) {
+  if (isConstructor(pluginType)) {
+    return new pluginType();
+  }
+  return pluginType;
+}
+__name(resolvePlugin, "resolvePlugin");
+function resolvePluginName(plugin, index, override) {
+  const resolved = override || plugin.meta?.name || plugin.constructor?.name;
+  if (!resolved || resolved === DEFAULT_PLUGIN_NAME) {
+    return `${DEFAULT_PLUGIN_NAME}#${index + 1}`;
+  }
+  return resolved;
+}
+__name(resolvePluginName, "resolvePluginName");
+function normalizePluginEntry(entry, index) {
+  if (entry && typeof entry === "object" && "plugin" in entry) {
+    const obj = entry;
+    const plugin2 = resolvePlugin(obj.plugin);
+    const name = resolvePluginName(plugin2, index, obj.name);
+    return {
+      plugin: plugin2,
+      name,
+      preProcessors: obj.preProcessors ?? [],
+      postProcessors: obj.postProcessors ?? []
+    };
+  }
+  const plugin = resolvePlugin(entry);
+  return {
+    plugin,
+    name: resolvePluginName(plugin, index),
+    preProcessors: [],
+    postProcessors: []
+  };
+}
+__name(normalizePluginEntry, "normalizePluginEntry");
+function normalizePluginEntries(plugins) {
+  return (plugins ?? []).map((entry, index) => normalizePluginEntry(entry, index));
+}
+__name(normalizePluginEntries, "normalizePluginEntries");
+
+// src/application-context.ts
+var ApplicationContext = class {
+  static {
+    __name(this, "ApplicationContext");
+  }
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  has(key) {
+    return this.store.has(key);
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  keys() {
+    return this.store.keys();
+  }
+};
+
+// src/loggers/console.logger.ts
+var ConsoleLogger = class {
+  static {
+    __name(this, "ConsoleLogger");
+  }
+  emit(event) {
+    const prefix = `[HonestJS:${event.category}]`;
+    const payload = event.details ? [
+      prefix,
+      event.message,
+      event.details
+    ] : [
+      prefix,
+      event.message
+    ];
+    switch (event.level) {
+      case "debug":
+      case "info":
+        console.info(...payload);
+        break;
+      case "warn":
+        console.warn(...payload);
+        break;
+      case "error":
+        console.error(...payload);
+        break;
+    }
+  }
+};
+
+// src/loggers/noop.logger.ts
+var NoopLogger = class {
+  static {
+    __name(this, "NoopLogger");
+  }
+  emit(_event) {
+  }
+};
+
+// src/registries/metadata.registry.ts
+var MetadataRegistry = class {
+  static {
+    __name(this, "MetadataRegistry");
+  }
+  /**
+  * Stores route definitions for each controller
+  * Maps controller classes to their route configurations
+  */
+  static routes = /* @__PURE__ */ new Map();
+  /**
+  * Stores base paths for controllers
+  * Maps controller classes to their route prefixes
+  */
+  static controllers = /* @__PURE__ */ new Map();
+  /**
+  * Stores configuration options for controllers
+  * Includes settings like versioning and prefix options
+  */
+  static controllerOptions = /* @__PURE__ */ new Map();
+  /**
+  * Registry of service classes
+  * Used for dependency injection and lifecycle management
+  */
+  static services = /* @__PURE__ */ new Set();
+  /**
+  * Stores configuration options for modules
+  * Includes imports, exports, providers, and controllers
+  */
+  static modules = /* @__PURE__ */ new Map();
+  /**
+  * Stores parameter metadata for controller methods
+  * Used for parameter transformation and validation
+  */
+  static parameters = /* @__PURE__ */ new Map();
+  /**
+  * Stores indices of context parameters in controller methods
+  * Used for optimizing context injection
+  */
+  static contextIndices = /* @__PURE__ */ new Map();
+  /**
+  * Registry for controller-level components
+  * Components registered here apply to all routes in a specific controller
+  */
+  static controller = /* @__PURE__ */ new Map([
+    [
+      "middleware",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "guard",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "pipe",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "filter",
+      /* @__PURE__ */ new Map()
+    ]
+  ]);
+  /**
+  * Registry for handler-level components
+  * Components registered here apply to specific route handlers
+  * Keyed by controller constructor then handler name for collision-safe lookups
+  */
+  static handler = /* @__PURE__ */ new Map([
+    [
+      "middleware",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "guard",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "pipe",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "filter",
+      /* @__PURE__ */ new Map()
+    ]
+  ]);
+  /**
+  * Gets all route definitions for a controller
+  * @param controller - The controller class to get routes for
+  * @returns Array of route definitions for the controller
+  */
+  static getRoutes(controller) {
+    return this.routes.get(controller) || [];
+  }
+  /**
+  * Set routes for a controller
+  */
+  static setRoutes(controller, routes) {
+    this.routes.set(controller, routes);
+  }
+  /**
+  * Add a route to a controller
+  */
+  static addRoute(controller, route) {
+    if (!this.routes.has(controller)) {
+      this.routes.set(controller, []);
+    }
+    this.routes.get(controller).push(route);
+  }
+  /**
+  * Get controller path
+  */
+  static getControllerPath(controller) {
+    return this.controllers.get(controller) || "";
+  }
+  /**
+  * Check if a class is registered as a controller.
+  */
+  static hasController(controller) {
+    return this.controllers.has(controller);
+  }
+  /**
+  * Set controller path
+  */
+  static setControllerPath(controller, path) {
+    this.controllers.set(controller, path);
+  }
+  /**
+  * Get controller options
+  */
+  static getControllerOptions(controller) {
+    return this.controllerOptions.get(controller) || {};
+  }
+  /**
+  * Set controller options
+  */
+  static setControllerOptions(controller, options) {
+    this.controllerOptions.set(controller, options);
+  }
+  /**
+  * Check if class is a service
+  */
+  static isService(service) {
+    return this.services.has(service);
+  }
+  /**
+  * Add a service
+  */
+  static addService(service) {
+    this.services.add(service);
+  }
+  /**
+  * Get all services
+  */
+  static getAllServices() {
+    return this.services;
+  }
+  /**
+  * Get module options
+  */
+  static getModuleOptions(module) {
+    return this.modules.get(module);
+  }
+  /**
+  * Set module options
+  */
+  static setModuleOptions(module, options) {
+    this.modules.set(module, options);
+  }
+  /**
+  * Get parameter metadata
+  */
+  static getParameters(controller) {
+    return this.parameters.get(controller) || /* @__PURE__ */ new Map();
+  }
+  /**
+  * Set parameter metadata
+  */
+  static setParameterMap(controller, params) {
+    this.parameters.set(controller, params);
+  }
+  /**
+  * Get context indices
+  */
+  static getContextIndices(controller) {
+    return this.contextIndices.get(controller) || /* @__PURE__ */ new Map();
+  }
+  /**
+  * Set context indices
+  */
+  static setContextIndices(controller, indices) {
+    this.contextIndices.set(controller, indices);
+  }
+  /**
+  * Register a component at the controller level
+  */
+  static registerController(type, controller, component) {
+    const typeMap = this.controller.get(type);
+    if (!typeMap.has(controller)) {
+      typeMap.set(controller, []);
+    }
+    typeMap.get(controller).push(component);
+  }
+  /**
+  * Get all controller-level components of a specific type for a controller
+  */
+  static getController(type, controller) {
+    const typeMap = this.controller.get(type);
+    return typeMap.get(controller) || [];
+  }
+  /**
+  * Register a component at the handler level
+  */
+  static registerHandler(type, controller, handlerName, component) {
+    const typeMap = this.handler.get(type);
+    if (!typeMap.has(controller)) {
+      typeMap.set(controller, /* @__PURE__ */ new Map());
+    }
+    const controllerMap = typeMap.get(controller);
+    if (!controllerMap.has(handlerName)) {
+      controllerMap.set(handlerName, []);
+    }
+    controllerMap.get(handlerName).push(component);
+  }
+  /**
+  * Get all handler-level components of a specific type for a handler
+  */
+  static getHandler(type, controller, handlerName) {
+    const typeMap = this.handler.get(type);
+    const controllerMap = typeMap.get(controller);
+    if (!controllerMap) {
+      return [];
+    }
+    return controllerMap.get(handlerName) || [];
+  }
+  /**
+  * Clears handler-level component registrations created via {@link registerHandler}.
+  * Does not remove decorator-defined routes, controllers, or modules.
+  */
+  static clearHandlerComponents() {
+    for (const typeMap of this.handler.values()) {
+      for (const controllerMap of typeMap.values()) {
+        controllerMap.clear();
+      }
+      typeMap.clear();
+    }
+  }
+  /**
+  * Clears all registered decorator metadata.
+  * Primarily used for testing. Warning: clearing after importing decorated classes
+  * (e.g. shared fixtures) removes their metadata until those modules are re-evaluated.
+  */
+  static clear() {
+    this.routes.clear();
+    this.controllers.clear();
+    this.controllerOptions.clear();
+    this.services.clear();
+    this.modules.clear();
+    this.parameters.clear();
+    this.contextIndices.clear();
+    for (const map of this.controller.values()) {
+      map.clear();
+    }
+    for (const typeMap of this.handler.values()) {
+      for (const controllerMap of typeMap.values()) {
+        controllerMap.clear();
+      }
+      typeMap.clear();
+    }
+  }
+};
+
+// src/registries/metadata.repository.ts
+var MetadataRepository = class _MetadataRepository {
+  static {
+    __name(this, "MetadataRepository");
+  }
+  controllerPaths = /* @__PURE__ */ new Map();
+  controllerOptions = /* @__PURE__ */ new Map();
+  routes = /* @__PURE__ */ new Map();
+  parameters = /* @__PURE__ */ new Map();
+  contextIndices = /* @__PURE__ */ new Map();
+  modules = /* @__PURE__ */ new Map();
+  controllerComponents = /* @__PURE__ */ new Map([
+    [
+      "middleware",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "guard",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "pipe",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "filter",
+      /* @__PURE__ */ new Map()
+    ]
+  ]);
+  handlerComponents = /* @__PURE__ */ new Map([
+    [
+      "middleware",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "guard",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "pipe",
+      /* @__PURE__ */ new Map()
+    ],
+    [
+      "filter",
+      /* @__PURE__ */ new Map()
+    ]
+  ]);
+  static fromRootModule(rootModule) {
+    const snapshot = new _MetadataRepository();
+    snapshot.captureModuleGraph(rootModule);
+    return snapshot;
+  }
+  hasController(controller) {
+    return this.controllerPaths.has(controller);
+  }
+  getControllerPath(controller) {
+    return this.controllerPaths.get(controller) || "";
+  }
+  getControllerOptions(controller) {
+    const options = this.controllerOptions.get(controller);
+    return options ? {
+      ...options
+    } : {};
+  }
+  getRoutes(controller) {
+    return (this.routes.get(controller) || []).map((route) => this.cloneRouteDefinition(route));
+  }
+  getParameters(controller) {
+    const parameters = this.parameters.get(controller);
+    if (!parameters) {
+      return /* @__PURE__ */ new Map();
+    }
+    const cloned = /* @__PURE__ */ new Map();
+    for (const [handlerName, entries] of parameters.entries()) {
+      cloned.set(handlerName, entries.map((entry) => ({
+        ...entry
+      })));
+    }
+    return cloned;
+  }
+  getContextIndices(controller) {
+    return new Map(this.contextIndices.get(controller) || /* @__PURE__ */ new Map());
+  }
+  getModuleOptions(module) {
+    const options = this.modules.get(module);
+    if (!options) {
+      return void 0;
+    }
+    return {
+      controllers: options.controllers ? [
+        ...options.controllers
+      ] : void 0,
+      services: options.services ? [
+        ...options.services
+      ] : void 0,
+      imports: options.imports ? [
+        ...options.imports
+      ] : void 0
+    };
+  }
+  getControllerComponents(type, controller) {
+    const map = this.controllerComponents.get(type);
+    const components = map.get(controller) || [];
+    return [
+      ...components
+    ];
+  }
+  getHandlerComponents(type, controller, handlerName) {
+    const typeMap = this.handlerComponents.get(type);
+    const controllerMap = typeMap.get(controller);
+    if (!controllerMap) {
+      return [];
+    }
+    const components = controllerMap.get(handlerName) || [];
+    return [
+      ...components
+    ];
+  }
+  captureModuleGraph(rootModule) {
+    const visitedModules = /* @__PURE__ */ new Set();
+    const controllers = /* @__PURE__ */ new Set();
+    const visitModule = /* @__PURE__ */ __name((moduleClass) => {
+      if (visitedModules.has(moduleClass)) {
+        return;
+      }
+      visitedModules.add(moduleClass);
+      const moduleOptions = MetadataRegistry.getModuleOptions(moduleClass);
+      if (!moduleOptions) {
+        return;
+      }
+      const moduleSnapshot = {
+        controllers: moduleOptions.controllers ? [
+          ...moduleOptions.controllers
+        ] : void 0,
+        services: moduleOptions.services ? [
+          ...moduleOptions.services
+        ] : void 0,
+        imports: moduleOptions.imports ? [
+          ...moduleOptions.imports
+        ] : void 0
+      };
+      this.modules.set(moduleClass, moduleSnapshot);
+      for (const controller of moduleSnapshot.controllers || []) {
+        controllers.add(controller);
+      }
+      for (const importedModule of moduleSnapshot.imports || []) {
+        visitModule(importedModule);
+      }
+    }, "visitModule");
+    visitModule(rootModule);
+    for (const controller of controllers) {
+      this.captureController(controller);
+    }
+  }
+  captureController(controller) {
+    if (!MetadataRegistry.hasController(controller)) {
+      return;
+    }
+    this.controllerPaths.set(controller, MetadataRegistry.getControllerPath(controller) || "");
+    this.controllerOptions.set(controller, {
+      ...MetadataRegistry.getControllerOptions(controller)
+    });
+    const routes = (MetadataRegistry.getRoutes(controller) || []).map((route) => this.cloneRouteDefinition(route));
+    this.routes.set(controller, routes);
+    const parameters = MetadataRegistry.getParameters(controller);
+    const parameterSnapshot = /* @__PURE__ */ new Map();
+    for (const [handlerName, entries] of parameters.entries()) {
+      parameterSnapshot.set(handlerName, (entries || []).map((entry) => ({
+        ...entry
+      })));
+    }
+    this.parameters.set(controller, parameterSnapshot);
+    this.contextIndices.set(controller, new Map(MetadataRegistry.getContextIndices(controller) || /* @__PURE__ */ new Map()));
+    for (const type of [
+      "middleware",
+      "guard",
+      "pipe",
+      "filter"
+    ]) {
+      const controllerMap = this.controllerComponents.get(type);
+      controllerMap.set(controller, [
+        ...MetadataRegistry.getController(type, controller) || []
+      ]);
+    }
+    for (const route of routes) {
+      for (const type of [
+        "middleware",
+        "guard",
+        "pipe",
+        "filter"
+      ]) {
+        const typeMap = this.handlerComponents.get(type);
+        if (!typeMap.has(controller)) {
+          typeMap.set(controller, /* @__PURE__ */ new Map());
+        }
+        const controllerHandlers = typeMap.get(controller);
+        controllerHandlers.set(route.handlerName, [
+          ...MetadataRegistry.getHandler(type, controller, route.handlerName)
+        ]);
+      }
+    }
+  }
+  cloneRouteDefinition(route) {
+    return {
+      ...route,
+      version: Array.isArray(route.version) ? [
+        ...route.version
+      ] : route.version
+    };
+  }
+};
+
+// src/registries/route.registry.ts
+var RouteRegistry = class {
+  static {
+    __name(this, "RouteRegistry");
+  }
+  routes = [];
+  registerRoute(routeInfo) {
+    if (!routeInfo) {
+      throw new Error("Route info is required");
+    }
+    if (!routeInfo.controller) {
+      throw new Error("Route controller is required");
+    }
+    if (!routeInfo.handler) {
+      throw new Error("Route handler is required");
+    }
+    if (!routeInfo.method) {
+      throw new Error("Route method is required");
+    }
+    if (!routeInfo.fullPath) {
+      throw new Error("Route fullPath is required");
+    }
+    const isDuplicate = this.routes.some((route) => route.fullPath === routeInfo.fullPath && route.method.toUpperCase() === routeInfo.method.toUpperCase());
+    if (isDuplicate) {
+      throw new Error(`Duplicate route detected: ${routeInfo.method.toUpperCase()} ${routeInfo.fullPath} (${String(routeInfo.controller)}.${String(routeInfo.handler)})`);
+    }
+    this.routes.push(routeInfo);
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getRoutesByController(controllerName) {
+    return this.routes.filter((route) => route.controller === controllerName);
+  }
+  getRoutesByMethod(method) {
+    return this.routes.filter((route) => route.method.toUpperCase() === method.toUpperCase());
+  }
+  getRoutesByPath(pattern) {
+    return this.routes.filter((route) => pattern.test(route.fullPath));
+  }
+  clear() {
+    this.routes.length = 0;
+  }
+};
+
+// src/registries/service.registry.ts
+var StaticServiceRegistry = class {
+  static {
+    __name(this, "StaticServiceRegistry");
+  }
+  isService(service) {
+    return MetadataRegistry.isService(service);
+  }
+};
+
+// src/di/container.ts
+var Container = class {
+  static {
+    __name(this, "Container");
+  }
+  serviceRegistry;
+  logger;
+  debugDi;
+  constructor(serviceRegistry = new StaticServiceRegistry(), logger = new NoopLogger(), debugDi = false) {
+    this.serviceRegistry = serviceRegistry;
+    this.logger = logger;
+    this.debugDi = debugDi;
+  }
+  /**
+  * Map of class constructors to their instances
+  */
+  instances = /* @__PURE__ */ new Map();
+  emitLog(event) {
+    if (!this.debugDi) {
+      return;
+    }
+    this.logger.emit(event);
+  }
+  /**
+  * Resolves a class instance, creating it if necessary and injecting its dependencies
+  * @param target - The class constructor to resolve
+  * @returns An instance of the target class
+  */
+  resolve(target) {
+    return this.resolveWithTracking(target, /* @__PURE__ */ new Set());
+  }
+  /**
+  * Internal recursive resolver with circular dependency tracking
+  */
+  resolveWithTracking(target, resolving) {
+    if (this.instances.has(target)) {
+      this.emitLog({
+        level: "debug",
+        category: "di",
+        message: `Resolved ${target.name} from DI cache`
+      });
+      return this.instances.get(target);
+    }
+    if (resolving.has(target)) {
+      const cycle = [
+        ...resolving.keys(),
+        target
+      ].map((t) => t.name).join(" -> ");
+      this.emitLog({
+        level: "error",
+        category: "di",
+        message: `Circular dependency detected while resolving ${target.name}`,
+        details: {
+          cycle
+        }
+      });
+      throw new Error(`Circular dependency detected: ${cycle}`);
+    }
+    resolving.add(target);
+    this.emitLog({
+      level: "debug",
+      category: "di",
+      message: `Resolving ${target.name}`,
+      details: {
+        resolving: [
+          ...resolving
+        ].map((constructor) => constructor.name)
+      }
+    });
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+    if (target.length > 0 && paramTypes.length === 0) {
+      if (!this.serviceRegistry.isService(target)) {
+        this.emitLog({
+          level: "error",
+          category: "di",
+          message: `Cannot resolve ${target.name}: missing @Service() decorator`
+        });
+        throw new Error(`Cannot resolve ${target.name}: it is not decorated with @Service(). Did you forget to add @Service() to the class?`);
+      }
+      this.emitLog({
+        level: "error",
+        category: "di",
+        message: `Cannot resolve ${target.name}: missing constructor metadata`
+      });
+      throw new Error(`Cannot resolve dependencies for ${target.name}: constructor metadata is missing. Ensure 'reflect-metadata' is imported and 'emitDecoratorMetadata' is enabled.`);
+    }
+    const dependencies = paramTypes.map((paramType, index) => {
+      if (!paramType || paramType === Object || paramType === Array || paramType === Function) {
+        this.emitLog({
+          level: "error",
+          category: "di",
+          message: `Cannot resolve dependency at index ${index} of ${target.name}`
+        });
+        throw new Error(`Cannot resolve dependency at index ${index} of ${target.name}. Use concrete class types for constructor dependencies.`);
+      }
+      return this.resolveWithTracking(paramType, new Set(resolving));
+    });
+    const instance = new target(...dependencies);
+    this.instances.set(target, instance);
+    this.emitLog({
+      level: "debug",
+      category: "di",
+      message: `Created ${target.name} instance`,
+      details: {
+        dependencyCount: dependencies.length
+      }
+    });
+    return instance;
+  }
+  /**
+  * Registers a pre-created instance for a class
+  * @param target - The class constructor to register
+  * @param instance - The instance to register
+  */
+  register(target, instance) {
+    this.instances.set(target, instance);
+  }
+  has(target) {
+    return this.instances.has(target);
+  }
+  clear() {
+    this.instances.clear();
+  }
+};
+
+// src/errors/framework.error.ts
+var FrameworkError = class extends Error {
+  static {
+    __name(this, "FrameworkError");
+  }
+  status;
+  code;
+  category;
+  remediation;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "FrameworkError";
+    this.status = options.status;
+    this.code = options.code;
+    this.category = options.category;
+    this.remediation = options.remediation;
+    this.details = options.details;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// src/helpers/create-error-response.helper.ts
+function createErrorResponse(exception, context, options) {
+  const normalizedException = exception instanceof Error ? exception : new Error(String(exception));
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const requestId = context.get("requestId");
+  const path = context.req.path;
+  if (normalizedException instanceof httpException.HTTPException) {
+    const response2 = {
+      status: options?.status || normalizedException.status,
+      message: options?.title || normalizedException.message,
+      timestamp,
+      path,
+      requestId,
+      code: options?.code,
+      details: options?.additionalDetails,
+      ...options?.detail && {
+        detail: options.detail
+      }
+    };
+    return {
+      response: response2,
+      status: options?.status || normalizedException.status
+    };
+  }
+  if (normalizedException instanceof FrameworkError) {
+    const status2 = options?.status || normalizedException.status || 500;
+    const response2 = {
+      status: status2,
+      message: options?.title || normalizedException.message,
+      timestamp,
+      path,
+      requestId,
+      code: options?.code || normalizedException.code,
+      details: {
+        category: normalizedException.category,
+        remediation: normalizedException.remediation,
+        ...normalizedException.details,
+        ...options?.additionalDetails
+      },
+      ...options?.detail && {
+        detail: options.detail
+      }
+    };
+    return {
+      response: response2,
+      status: status2
+    };
+  }
+  if (normalizedException.statusCode || normalizedException.status) {
+    const defaultStatus = normalizedException.statusCode || normalizedException.status || 500;
+    const status2 = options?.status || defaultStatus;
+    const response2 = {
+      status: status2,
+      message: options?.title || normalizedException.message,
+      timestamp,
+      path,
+      requestId,
+      code: options?.code || normalizedException.name,
+      details: options?.additionalDetails,
+      ...options?.detail && {
+        detail: options.detail
+      }
+    };
+    return {
+      response: response2,
+      status: status2
+    };
+  }
+  const status = options?.status || 500;
+  const response = {
+    status,
+    message: options?.title || (process.env.NODE_ENV === "production" ? "Internal Server Error" : normalizedException.message),
+    timestamp,
+    path,
+    requestId,
+    code: options?.code || normalizedException.name,
+    details: options?.additionalDetails || (process.env.NODE_ENV === "development" ? {
+      stack: normalizedException.stack
+    } : void 0),
+    ...options?.detail && {
+      detail: options.detail
+    }
+  };
+  return {
+    response,
+    status
+  };
+}
+__name(createErrorResponse, "createErrorResponse");
+
+// src/helpers/create-http-method-decorator.helper.ts
+function createHttpMethodDecorator(method) {
+  return (path = "", options = {}) => {
+    return (target, propertyKey, descriptor) => {
+      const controllerClass = target.constructor;
+      MetadataRegistry.addRoute(controllerClass, {
+        path,
+        method,
+        handlerName: propertyKey,
+        version: options.version,
+        prefix: options.prefix
+      });
+    };
+  };
+}
+__name(createHttpMethodDecorator, "createHttpMethodDecorator");
+
+// src/helpers/create-param-decorator.helper.ts
+function createParamDecorator(type, factory) {
+  const fallbackFactory = /* @__PURE__ */ __name((data, ctx) => {
+    if (data === void 0) {
+      return ctx;
+    }
+    return ctx.get(String(data));
+  }, "fallbackFactory");
+  return (data) => {
+    return (target, propertyKey, parameterIndex) => {
+      const controllerClass = target.constructor;
+      if (!MetadataRegistry.getParameters(controllerClass).size) {
+        MetadataRegistry.setParameterMap(controllerClass, /* @__PURE__ */ new Map());
+      }
+      const parametersMap = MetadataRegistry.getParameters(controllerClass);
+      if (!parametersMap.has(propertyKey)) {
+        parametersMap.set(propertyKey, []);
+      }
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+      const metatype = paramTypes?.[parameterIndex];
+      const parameters = parametersMap.get(propertyKey);
+      parameters.push({
+        index: parameterIndex,
+        name: type,
+        data,
+        factory: factory || fallbackFactory,
+        metatype
+      });
+      if (type === "context") {
+        if (!MetadataRegistry.getContextIndices(controllerClass).size) {
+          MetadataRegistry.setContextIndices(controllerClass, /* @__PURE__ */ new Map());
+        }
+        const contextIndices = MetadataRegistry.getContextIndices(controllerClass);
+        contextIndices.set(propertyKey, parameterIndex);
+      }
+    };
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+
+// src/handlers/error.handler.ts
+var ErrorHandler = class {
+  static {
+    __name(this, "ErrorHandler");
+  }
+  /**
+  * Creates a middleware function that handles error responses
+  * @returns A middleware function that formats and returns error responses using createErrorResponse
+  */
+  static handle() {
+    return async (err, c) => {
+      const { response, status } = createErrorResponse(err, c);
+      return c.json(response, status);
+    };
+  }
+};
+
+// src/handlers/not-found.handler.ts
+var NotFoundHandler = class {
+  static {
+    __name(this, "NotFoundHandler");
+  }
+  /**
+  * Creates a middleware function that handles 404 Not Found responses
+  * @returns A middleware function that returns a JSON response with a 404 status
+  */
+  static handle() {
+    return async (c) => {
+      return c.json({
+        message: `Not Found - ${c.req.path}`
+      }, 404);
+    };
+  }
+};
+
+// src/constants/version.constants.ts
+var VERSION_NEUTRAL = /* @__PURE__ */ Symbol("VERSION_NEUTRAL");
+
+// src/constants/pipeline.constants.ts
+var HONEST_PIPELINE_CONTROLLER_KEY = "__honest_controllerClass";
+var HONEST_PIPELINE_HANDLER_KEY = "__honest_handlerName";
+var HONEST_PIPELINE_BODY_CACHE_KEY = "__honest.body.cache";
+
+// src/managers/component.manager.ts
+var ComponentManager = class {
+  static {
+    __name(this, "ComponentManager");
+  }
+  container;
+  metadataRepository;
+  logger;
+  globalComponents = /* @__PURE__ */ new Map([
+    [
+      "middleware",
+      /* @__PURE__ */ new Set()
+    ],
+    [
+      "guard",
+      /* @__PURE__ */ new Set()
+    ],
+    [
+      "pipe",
+      /* @__PURE__ */ new Set()
+    ],
+    [
+      "filter",
+      /* @__PURE__ */ new Set()
+    ]
+  ]);
+  constructor(container, metadataRepository, logger = new NoopLogger()) {
+    this.container = container;
+    this.metadataRepository = metadataRepository;
+    this.logger = logger;
+  }
+  /**
+  * Configures global components from application options.
+  */
+  setupGlobalComponents(options) {
+    const components = options.components || {};
+    if (components.middleware) {
+      this.registerGlobal("middleware", ...components.middleware);
+    }
+    if (components.guards) {
+      this.registerGlobal("guard", ...components.guards);
+    }
+    if (components.pipes) {
+      this.registerGlobal("pipe", ...components.pipes);
+    }
+    if (components.filters) {
+      this.registerGlobal("filter", ...components.filters);
+    }
+  }
+  registerGlobal(type, ...components) {
+    components.forEach((component) => {
+      this.globalComponents.get(type).add(component);
+    });
+  }
+  getGlobal(type) {
+    return this.globalComponents.get(type);
+  }
+  /**
+  * Gets all components of a specific type for a handler.
+  * Merges: instance global → static controller → static handler.
+  */
+  getComponents(type, controller, handlerName) {
+    const handlerComponents = this.metadataRepository.getHandlerComponents(type, controller, handlerName);
+    const controllerComponents = this.metadataRepository.getControllerComponents(type, controller);
+    const globalComponents = Array.from(this.globalComponents.get(type) || []);
+    return [
+      ...globalComponents,
+      ...controllerComponents,
+      ...handlerComponents
+    ];
+  }
+  // -- Middleware --
+  resolveMiddleware(middlewareItems) {
+    return middlewareItems.map((middlewareItem) => {
+      if (isObject(middlewareItem) && "use" in middlewareItem) {
+        return middlewareItem.use.bind(middlewareItem);
+      }
+      const middleware = this.container.resolve(middlewareItem);
+      return middleware.use.bind(middleware);
+    });
+  }
+  getHandlerMiddleware(controller, handlerName) {
+    const controllerMiddleware = this.metadataRepository.getControllerComponents("middleware", controller);
+    const handlerMiddleware = this.metadataRepository.getHandlerComponents("middleware", controller, handlerName);
+    return this.resolveMiddleware([
+      ...controllerMiddleware,
+      ...handlerMiddleware
+    ]);
+  }
+  getGlobalMiddleware() {
+    const globalMiddleware = Array.from(this.globalComponents.get("middleware") || []);
+    return this.resolveMiddleware(globalMiddleware);
+  }
+  // -- Guards --
+  resolveGuards(guardItems) {
+    return guardItems.map((guardItem) => {
+      if (isObject(guardItem) && "canActivate" in guardItem) {
+        return guardItem;
+      }
+      return this.container.resolve(guardItem);
+    });
+  }
+  getHandlerGuards(controller, handlerName) {
+    const guardItems = this.getComponents("guard", controller, handlerName);
+    return this.resolveGuards(guardItems);
+  }
+  // -- Pipes --
+  resolvePipes(pipeItems) {
+    return pipeItems.map((pipeItem) => {
+      if (isObject(pipeItem) && "transform" in pipeItem) {
+        return pipeItem;
+      }
+      return this.container.resolve(pipeItem);
+    });
+  }
+  getHandlerPipes(controller, handlerName) {
+    const pipeItems = this.getComponents("pipe", controller, handlerName);
+    return this.resolvePipes(pipeItems);
+  }
+  async executePipes(value, metadata, pipes) {
+    let transformedValue = value;
+    for (const pipe of pipes) {
+      transformedValue = await pipe.transform(transformedValue, metadata);
+    }
+    return transformedValue;
+  }
+  // -- Filters --
+  async handleException(exception, context) {
+    const normalizedException = exception instanceof Error ? exception : new Error(String(exception));
+    const controller = context.get(HONEST_PIPELINE_CONTROLLER_KEY);
+    const handlerName = context.get(HONEST_PIPELINE_HANDLER_KEY);
+    if (controller && handlerName) {
+      const handlerFilters = this.metadataRepository.getHandlerComponents("filter", controller, handlerName);
+      if (handlerFilters.length > 0) {
+        const response2 = await this.executeFilters(handlerFilters, normalizedException, context);
+        if (response2) return response2;
+      }
+    }
+    if (controller) {
+      const controllerFilters = this.metadataRepository.getControllerComponents("filter", controller);
+      if (controllerFilters.length > 0) {
+        const response2 = await this.executeFilters(controllerFilters, normalizedException, context);
+        if (response2) return response2;
+      }
+    }
+    const globalFilters = Array.from(this.globalComponents.get("filter") || []);
+    if (globalFilters.length > 0) {
+      const response2 = await this.executeFilters(globalFilters, normalizedException, context);
+      if (response2) return response2;
+    }
+    const { response, status } = createErrorResponse(normalizedException, context);
+    return context.json(response, status);
+  }
+  async executeFilters(filterItems, exception, context) {
+    for (const filterItem of filterItems) {
+      let filter;
+      if (isObject(filterItem) && "catch" in filterItem) {
+        filter = filterItem;
+      } else {
+        filter = this.container.resolve(filterItem);
+      }
+      try {
+        const result = await filter.catch(exception, context);
+        if (result !== void 0) {
+          return result;
+        }
+      } catch (filterError) {
+        const filterName = filter.constructor?.name || "UnknownFilter";
+        this.logger.emit({
+          level: "error",
+          category: "errors",
+          message: `Error in exception filter ${filterName}`,
+          details: {
+            error: filterError instanceof Error ? filterError.message : String(filterError)
+          }
+        });
+        const { response, status } = createErrorResponse(filterError, context);
+        return context.json(response, status);
+      }
+    }
+    return void 0;
+  }
+  // -- Module registration --
+  async registerModule(moduleClass, registered = /* @__PURE__ */ new Set()) {
+    if (registered.has(moduleClass)) {
+      return [];
+    }
+    registered.add(moduleClass);
+    const moduleOptions = this.metadataRepository.getModuleOptions(moduleClass);
+    if (!moduleOptions) {
+      this.logger.emit({
+        level: "error",
+        category: "startup",
+        message: `Module ${moduleClass.name} is not properly decorated with @Module()`
+      });
+      throw new Error(`Module ${moduleClass.name} is not properly decorated with @Module()`);
+    }
+    const controllers = [];
+    if (moduleOptions.imports && moduleOptions.imports.length > 0) {
+      for (const importedModule of moduleOptions.imports) {
+        const importedControllers = await this.registerModule(importedModule, registered);
+        controllers.push(...importedControllers);
+      }
+    }
+    if (moduleOptions.services && moduleOptions.services.length > 0) {
+      for (const serviceClass of moduleOptions.services) {
+        this.container.resolve(serviceClass);
+      }
+    }
+    if (moduleOptions.controllers && moduleOptions.controllers.length > 0) {
+      controllers.push(...moduleOptions.controllers);
+    }
+    return controllers;
+  }
+};
+
+// src/managers/handler.invoker.ts
+var HandlerInvoker = class {
+  static {
+    __name(this, "HandlerInvoker");
+  }
+  async invoke({ handler, args, context, contextIndex }) {
+    const result = await handler(...args);
+    if (contextIndex !== void 0) {
+      return result;
+    }
+    if (result instanceof Response) {
+      return result;
+    }
+    if (isNil(result)) {
+      return context.json(null);
+    }
+    if (isString(result)) {
+      return context.text(result);
+    }
+    try {
+      return context.json(result);
+    } catch (error) {
+      throw new FrameworkError("Handler return value could not be serialized as JSON.", {
+        status: 500,
+        code: "RESPONSE_SERIALIZATION_FAILED",
+        category: "pipeline",
+        remediation: "Return JSON-serializable values from handlers or map custom values in a filter before returning.",
+        details: {
+          handlerResultType: typeof result
+        },
+        cause: error
+      });
+    }
+  }
+};
+
+// src/managers/parameter.resolver.ts
+var ParameterResolver = class {
+  static {
+    __name(this, "ParameterResolver");
+  }
+  componentManager;
+  logger;
+  debugPipeline;
+  constructor(componentManager, logger = new NoopLogger(), debugPipeline = false) {
+    this.componentManager = componentManager;
+    this.logger = logger;
+    this.debugPipeline = debugPipeline;
+  }
+  async resolveArguments(input) {
+    const { controllerName, handlerName, handlerArity, handlerParams, handlerPipes, context } = input;
+    const maxDecoratorIndex = handlerParams.length > 0 ? Math.max(...handlerParams.map((parameter) => parameter.index)) : -1;
+    const args = new Array(Math.max(handlerArity, maxDecoratorIndex + 1));
+    const decoratedIndices = new Set(handlerParams.map((parameter) => parameter.index));
+    if (this.debugPipeline && maxDecoratorIndex >= 0) {
+      const sparseIndices = [];
+      for (let i = 0; i <= maxDecoratorIndex; i++) {
+        if (!decoratedIndices.has(i)) {
+          sparseIndices.push(i);
+        }
+      }
+      const hasOutOfRangeDecoratorIndex = maxDecoratorIndex >= handlerArity;
+      if (sparseIndices.length > 0 || hasOutOfRangeDecoratorIndex) {
+        this.logger.emit({
+          level: "warn",
+          category: "pipeline",
+          message: `Potential parameter binding mismatch at ${controllerName}.${String(handlerName)}`,
+          details: {
+            handlerArity,
+            maxDecoratorIndex,
+            sparseIndices,
+            handlerParamCount: handlerParams.length
+          }
+        });
+      }
+    }
+    for (const parameter of handlerParams) {
+      if (typeof parameter.factory !== "function") {
+        throw new Error(`Invalid parameter decorator metadata for ${controllerName}.${String(handlerName)}`);
+      }
+      const rawValue = await parameter.factory(parameter.data, context);
+      const transformedValue = await this.componentManager.executePipes(rawValue, {
+        type: parameter.name,
+        metatype: parameter.metatype,
+        data: typeof parameter.data === "string" || typeof parameter.data === "undefined" ? parameter.data : String(parameter.data)
+      }, handlerPipes);
+      args[parameter.index] = transformedValue;
+    }
+    return args;
+  }
+};
+var PipelineExecutor = class {
+  static {
+    __name(this, "PipelineExecutor");
+  }
+  componentManager;
+  parameterResolver;
+  handlerInvoker;
+  logger;
+  debugPipeline;
+  constructor(componentManager, parameterResolver, handlerInvoker, logger = new NoopLogger(), debugPipeline = false) {
+    this.componentManager = componentManager;
+    this.parameterResolver = parameterResolver;
+    this.handlerInvoker = handlerInvoker;
+    this.logger = logger;
+    this.debugPipeline = debugPipeline;
+  }
+  async execute(input) {
+    const { controllerClass, handlerName, handler, handlerParams, handlerPipes, contextIndex, context } = input;
+    context.set(HONEST_PIPELINE_CONTROLLER_KEY, controllerClass);
+    context.set(HONEST_PIPELINE_HANDLER_KEY, String(handlerName));
+    const guards = this.componentManager.getHandlerGuards(controllerClass, handlerName);
+    for (const guard of guards) {
+      const canActivate = await guard.canActivate(context);
+      if (!canActivate) {
+        if (this.debugPipeline) {
+          this.logger.emit({
+            level: "warn",
+            category: "pipeline",
+            message: `Guard rejected request at ${controllerClass.name}.${String(handlerName)}`,
+            details: {
+              guard: guard.constructor?.name || "UnknownGuard"
+            }
+          });
+        }
+        throw new httpException.HTTPException(403, {
+          message: `Forbidden by ${guard.constructor?.name || "UnknownGuard"} at ${controllerClass.name}.${String(handlerName)}`
+        });
+      }
+    }
+    const args = await this.parameterResolver.resolveArguments({
+      controllerName: controllerClass.name,
+      handlerName,
+      handlerArity: handler.length,
+      handlerParams,
+      handlerPipes,
+      context
+    });
+    if (this.debugPipeline) {
+      this.logger.emit({
+        level: "debug",
+        category: "pipeline",
+        message: `Resolved handler arguments for ${controllerClass.name}.${String(handlerName)}`,
+        details: {
+          guardCount: guards.length,
+          parameterCount: handlerParams.length,
+          pipeCount: handlerPipes.length
+        }
+      });
+    }
+    return this.handlerInvoker.invoke({
+      handler,
+      args,
+      context,
+      contextIndex
+    });
+  }
+};
+
+// src/managers/route.manager.ts
+var RouteManager = class {
+  static {
+    __name(this, "RouteManager");
+  }
+  hono;
+  container;
+  routeRegistry;
+  componentManager;
+  parameterResolver;
+  pipelineExecutor;
+  metadataRepository;
+  logger;
+  globalPrefix;
+  globalVersion;
+  constructor(hono, container, routeRegistry, componentManager, metadataRepository, logger = new NoopLogger(), options = {}) {
+    this.hono = hono;
+    this.container = container;
+    this.routeRegistry = routeRegistry;
+    this.componentManager = componentManager;
+    this.logger = logger;
+    this.parameterResolver = new ParameterResolver(this.componentManager, this.logger, Boolean(options.debugPipeline));
+    this.pipelineExecutor = new PipelineExecutor(this.componentManager, this.parameterResolver, new HandlerInvoker(), this.logger, Boolean(options.debugPipeline));
+    this.metadataRepository = metadataRepository;
+    this.globalPrefix = options.prefix !== void 0 ? this.normalizePath(options.prefix) : void 0;
+    this.globalVersion = options.version;
+    this.applyGlobalMiddleware();
+  }
+  applyGlobalMiddleware() {
+    const globalMiddleware = this.componentManager.getGlobalMiddleware();
+    for (const middleware of globalMiddleware) {
+      this.hono.use("*", middleware);
+    }
+  }
+  normalizePath(path) {
+    if (!isString(path)) {
+      throw new Error(`Invalid path: expected a string but received ${typeof path}. Check your @Controller() and route decorator arguments.`);
+    }
+    return normalizePath(path);
+  }
+  registerRouteHandler(method, path, handlerMiddleware, wrapperHandler) {
+    if (handlerMiddleware.length > 0) {
+      this.hono.on(method.toUpperCase(), [
+        path
+      ], ...handlerMiddleware, wrapperHandler);
+    } else {
+      this.hono.on(method.toUpperCase(), [
+        path
+      ], wrapperHandler);
+    }
+  }
+  buildRoutePath(prefix, version, controllerPath, methodPath) {
+    return normalizePath(`${prefix}${version}${controllerPath}${methodPath}`);
+  }
+  formatVersionSegment(version) {
+    if (isNil(version)) {
+      return "";
+    }
+    return version === VERSION_NEUTRAL ? "" : `/v${String(version)}`;
+  }
+  async registerController(controllerClass) {
+    if (!this.metadataRepository.hasController(controllerClass)) {
+      throw new Error(`Controller ${controllerClass.name} is not decorated with @Controller()`);
+    }
+    const controllerPath = this.metadataRepository.getControllerPath(controllerClass) || "";
+    const controllerOptions = this.metadataRepository.getControllerOptions(controllerClass) || {};
+    const routes = this.metadataRepository.getRoutes(controllerClass) || [];
+    const parameterMetadata = this.metadataRepository.getParameters(controllerClass) || /* @__PURE__ */ new Map();
+    const contextIndices = this.metadataRepository.getContextIndices(controllerClass) || /* @__PURE__ */ new Map();
+    const controllerSegment = this.normalizePath(controllerPath);
+    const controllerInstance = this.container.resolve(controllerClass);
+    const effectiveControllerPrefix = controllerOptions.prefix !== void 0 ? controllerOptions.prefix : this.globalPrefix;
+    const effectiveControllerVersion = controllerOptions.version !== void 0 ? controllerOptions.version : this.globalVersion;
+    if (routes.length === 0) {
+      throw new Error(`Controller ${controllerClass.name} has no route handlers. Add HTTP method decorators like @Get()`);
+    }
+    for (const route of routes) {
+      const { path, method, version: routeVersion, prefix: routePrefix } = route;
+      const effectivePrefix = routePrefix !== void 0 ? routePrefix : effectiveControllerPrefix;
+      const prefixSegment = !isNil(effectivePrefix) ? this.normalizePath(effectivePrefix) : "";
+      const effectiveVersion = routeVersion !== void 0 ? routeVersion : effectiveControllerVersion;
+      const methodSegment = this.normalizePath(path);
+      if (isNil(effectiveVersion)) {
+        this.registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, "", controllerSegment, methodSegment, method);
+        continue;
+      }
+      if (effectiveVersion === VERSION_NEUTRAL) {
+        this.registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, "", controllerSegment, methodSegment, method);
+        this.registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, "/:version{v[0-9]+}", controllerSegment, methodSegment, method);
+        continue;
+      }
+      if (Array.isArray(effectiveVersion)) {
+        for (const version of effectiveVersion) {
+          const versionSegment2 = this.formatVersionSegment(version);
+          this.registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, versionSegment2, controllerSegment, methodSegment, method);
+        }
+        continue;
+      }
+      const versionSegment = this.formatVersionSegment(effectiveVersion);
+      this.registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, versionSegment, controllerSegment, methodSegment, method);
+    }
+  }
+  registerRoute(controllerInstance, route, parameterMetadata, contextIndices, controllerClass, prefixSegment, versionSegment, controllerSegment, methodSegment, method) {
+    const { handlerName } = route;
+    const fullPath = this.buildRoutePath(prefixSegment, versionSegment, controllerSegment, methodSegment);
+    const handler = controllerInstance[handlerName].bind(controllerInstance);
+    const handlerParams = parameterMetadata.get(handlerName) || [];
+    const contextIndex = contextIndices.get(handlerName);
+    const handlerMiddleware = this.componentManager.getHandlerMiddleware(controllerClass, handlerName);
+    const handlerPipes = this.componentManager.getHandlerPipes(controllerClass, handlerName);
+    this.routeRegistry.registerRoute({
+      controller: controllerClass.name,
+      handler: handlerName,
+      method,
+      prefix: prefixSegment,
+      version: versionSegment,
+      route: controllerSegment,
+      path: methodSegment,
+      fullPath,
+      parameters: handlerParams
+    });
+    const componentManager = this.componentManager;
+    const pipelineExecutor = this.pipelineExecutor;
+    const wrapperHandler = /* @__PURE__ */ __name(async (c) => {
+      try {
+        return await pipelineExecutor.execute({
+          controllerClass,
+          handlerName,
+          handler,
+          handlerParams,
+          handlerPipes,
+          contextIndex,
+          context: c
+        });
+      } catch (error) {
+        return componentManager.handleException(error, c);
+      }
+    }, "wrapperHandler");
+    this.registerRouteHandler(method, fullPath, handlerMiddleware, wrapperHandler);
+  }
+};
+
+// src/application.ts
+var Application = class _Application {
+  static {
+    __name(this, "Application");
+  }
+  hono;
+  container;
+  context;
+  routeRegistry;
+  metadataRepository;
+  componentManager;
+  routeManager;
+  logger;
+  options;
+  constructor(options = {}, metadataRepository) {
+    this.options = isObject(options) ? options : {};
+    const debugPipeline = this.options.debug === true || typeof this.options.debug === "object" && Boolean(this.options.debug.pipeline);
+    const debugDi = this.options.debug === true || typeof this.options.debug === "object" && Boolean(this.options.debug.di);
+    this.hono = new hono.Hono(this.options.hono);
+    this.logger = this.options.logger || new ConsoleLogger();
+    this.container = this.options.container || new Container(void 0, this.logger, debugDi);
+    this.context = new ApplicationContext();
+    this.routeRegistry = new RouteRegistry();
+    this.metadataRepository = metadataRepository;
+    this.componentManager = new ComponentManager(this.container, this.metadataRepository, this.logger);
+    this.componentManager.setupGlobalComponents(this.options);
+    this.setupErrorHandlers();
+    this.routeManager = new RouteManager(this.hono, this.container, this.routeRegistry, this.componentManager, this.metadataRepository, this.logger, {
+      prefix: this.options.routing?.prefix,
+      version: this.options.routing?.version,
+      debugPipeline
+    });
+    if (this.options.deprecations?.printPreV1Warning) {
+      this.logger.emit({
+        level: "warn",
+        category: "deprecations",
+        message: "Pre-v1 warning: APIs may change before 1.0.0."
+      });
+    }
+  }
+  setupErrorHandlers() {
+    this.hono.notFound(this.options.notFound || NotFoundHandler.handle());
+    this.hono.onError(this.options.onError || ErrorHandler.handle());
+  }
+  shouldEmitRouteDiagnostics() {
+    const debug = this.options.debug;
+    return debug === true || typeof debug === "object" && Boolean(debug.routes);
+  }
+  emitStartupGuide(error, rootModule) {
+    emitStartupGuide(this.logger, this.options.startupGuide, error, rootModule);
+  }
+  async register(moduleClass) {
+    const controllers = await this.componentManager.registerModule(moduleClass);
+    const debugRoutes = this.shouldEmitRouteDiagnostics();
+    for (const controller of controllers) {
+      const controllerStartedAt = Date.now();
+      const routeCountBefore = this.routeRegistry.getRoutes().length;
+      try {
+        await this.routeManager.registerController(controller);
+        if (debugRoutes) {
+          this.logger.emit({
+            level: "info",
+            category: "routes",
+            message: "Registered controller routes",
+            details: {
+              controller: controller.name,
+              routeCountAdded: this.routeRegistry.getRoutes().length - routeCountBefore,
+              registrationDurationMs: Date.now() - controllerStartedAt
+            }
+          });
+        }
+      } catch (error) {
+        if (debugRoutes) {
+          this.logger.emit({
+            level: "error",
+            category: "routes",
+            message: "Failed to register controller routes",
+            details: {
+              controller: controller.name,
+              registrationDurationMs: Date.now() - controllerStartedAt,
+              errorMessage: error instanceof Error ? error.message : String(error)
+            }
+          });
+        }
+        throw error;
+      }
+    }
+    return this;
+  }
+  static async create(rootModule, options = {}) {
+    const startupStartedAt = Date.now();
+    const metadataSnapshot = MetadataRepository.fromRootModule(rootModule);
+    const app = new _Application(options, metadataSnapshot);
+    const entries = normalizePluginEntries(options.plugins);
+    const ctx = app.getContext();
+    const debug = options.debug;
+    const debugPlugins = debug === true || typeof debug === "object" && debug.plugins;
+    const debugRoutes = debug === true || typeof debug === "object" && debug.routes;
+    const debugStartup = debug === true || typeof debug === "object" && (debug.startup || debugRoutes);
+    let strictNoRoutesFailureEmitted = false;
+    try {
+      if (debugPlugins && entries.length > 0) {
+        app.logger.emit({
+          level: "info",
+          category: "plugins",
+          message: `Plugin order: ${entries.map(({ name }) => name).join(" -> ")}`
+        });
+      }
+      for (const { plugin, preProcessors } of entries) {
+        plugin.logger = app.logger;
+        for (const fn of preProcessors) {
+          await fn(app, app.hono, ctx);
+        }
+        if (plugin.beforeModulesRegistered) {
+          await plugin.beforeModulesRegistered(app, app.hono);
+        }
+      }
+      await app.register(rootModule);
+      const routes = app.getRoutes();
+      if (debugStartup) {
+        app.logger.emit({
+          level: "info",
+          category: "startup",
+          message: `Application registered ${routes.length} route(s)`,
+          details: {
+            routeCount: routes.length,
+            rootModule: rootModule.name
+          }
+        });
+      }
+      if (options.strict?.requireRoutes && routes.length === 0) {
+        strictNoRoutesFailureEmitted = true;
+        app.logger.emit({
+          level: "error",
+          category: "startup",
+          message: "Strict mode failed: no routes were registered",
+          details: {
+            rootModule: rootModule.name,
+            requireRoutes: true,
+            startupDurationMs: Date.now() - startupStartedAt
+          }
+        });
+        const strictError = new Error("Strict mode: no routes were registered. Check your module/controller decorators.");
+        app.emitStartupGuide(strictError, rootModule);
+        throw strictError;
+      }
+      if (debugRoutes) {
+        app.logger.emit({
+          level: "info",
+          category: "routes",
+          message: "Registered routes",
+          details: {
+            routes: routes.map((route) => `${route.method.toUpperCase()} ${route.fullPath}`)
+          }
+        });
+      }
+      for (const { plugin, postProcessors } of entries) {
+        if (plugin.afterModulesRegistered) {
+          await plugin.afterModulesRegistered(app, app.hono);
+        }
+        for (const fn of postProcessors) {
+          await fn(app, app.hono, ctx);
+        }
+      }
+      if (debugStartup) {
+        app.logger.emit({
+          level: "info",
+          category: "startup",
+          message: "Application startup completed",
+          details: {
+            rootModule: rootModule.name,
+            pluginCount: entries.length,
+            routeCount: routes.length,
+            startupDurationMs: Date.now() - startupStartedAt
+          }
+        });
+      }
+      return {
+        app,
+        hono: app.getApp()
+      };
+    } catch (error) {
+      app.emitStartupGuide(error, rootModule);
+      if (debugStartup && !strictNoRoutesFailureEmitted) {
+        app.logger.emit({
+          level: "error",
+          category: "startup",
+          message: "Application startup failed",
+          details: {
+            rootModule: rootModule.name,
+            startupDurationMs: Date.now() - startupStartedAt,
+            errorMessage: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+      throw error;
+    }
+  }
+  getApp() {
+    return this.hono;
+  }
+  getContainer() {
+    return this.container;
+  }
+  getContext() {
+    return this.context;
+  }
+  getRoutes() {
+    return this.routeRegistry.getRoutes();
+  }
+};
+var defaultSiteData = {
+  type: "website",
+  locale: "en_US"
+};
+var attrsToString = /* @__PURE__ */ __name((attrs) => {
+  if (!attrs) {
+    return "";
+  }
+  return Object.entries(attrs).map(([key, value]) => {
+    if (typeof value === "boolean") {
+      return value ? key : "";
+    }
+    const escapedValue = String(value).replace(/"/g, "&quot;");
+    return `${key}="${escapedValue}"`;
+  }).filter(Boolean).join(" ");
+}, "attrsToString");
+var Layout = /* @__PURE__ */ __name((props) => {
+  const data = {
+    ...defaultSiteData,
+    ...props
+  };
+  return html.html`
+		<!DOCTYPE html>
+		<html lang="${data.locale?.split("_")[0] || "en"}" ${html.raw(attrsToString(data.htmlAttributes))}>
+			<head ${html.raw(attrsToString(data.headAttributes))}>
+				<meta charset="UTF-8" />
+				<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+				${data.csp ? html.html`<meta http-equiv="Content-Security-Policy" content="${data.csp}" />` : ""}
+				<title>${data.title}</title>
+				${data.description ? html.html`<meta name="description" content="${data.description}" />` : ""}
+
+				<!-- Open Graph / Facebook -->
+				<meta prefix="og: http://ogp.me/ns#" />
+				<meta property="og:title" content="${data.title}" />
+				${data.description ? html.html`<meta property="og:description" content="${data.description}" />` : ""}
+				${data.image ? html.html`<meta property="og:image" content="${data.image}" />` : ""}
+				${data.url ? html.html`<meta property="og:url" content="${data.url}" />` : ""}
+				${data.locale ? html.html`<meta property="og:locale" content="${data.locale}" />` : ""}
+				${data.type ? html.html`<meta property="og:type" content="${data.type}" />` : ""}
+				${data.siteName ? html.html`<meta property="og:site_name" content="${data.siteName}" />` : ""}
+
+				<!-- Twitter -->
+				<meta
+					name="twitter:card"
+					content="${data.twitterCard || (data.image ? "summary_large_image" : "summary")}"
+				/>
+				<meta name="twitter:title" content="${data.title}" />
+				${data.description ? html.html`<meta name="twitter:description" content="${data.description}" />` : ""}
+				${data.image ? html.html`<meta name="twitter:image" content="${data.image}" />` : ""}
+
+				<!-- Custom Meta Tags -->
+				${data.customMeta ? data.customMeta.map((meta) => {
+    const nameAttr = meta.name ? `name="${meta.name}"` : "";
+    const propertyAttr = meta.property ? `property="${meta.property}"` : "";
+    return html.html`<meta ${nameAttr} ${propertyAttr} content="${meta.content}" />`;
+  }) : ""}
+
+				<!-- Favicon -->
+				${data.favicon ? html.html`<link rel="icon" href="${data.favicon}" />` : ""}
+
+				<!-- Stylesheets -->
+				${data.stylesheets ? data.stylesheets.map((href) => html.html`<link rel="stylesheet" href="${href}" />`) : ""}
+
+				<!-- Scripts -->
+				${data.scripts ? data.scripts.map((script) => {
+    if (typeof script === "string") {
+      return html.html`<script src="${script}"></script>`;
+    }
+    const { src, async, defer } = script;
+    if (async && defer) {
+      return html.html`<script src="${src}" async defer></script>`;
+    }
+    if (async) {
+      return html.html`<script src="${src}" async></script>`;
+    }
+    if (defer) {
+      return html.html`<script src="${src}" defer></script>`;
+    }
+    return html.html`<script src="${src}"></script>`;
+  }) : ""}
+			</head>
+			<body ${html.raw(attrsToString(data.bodyAttributes))}>
+				${data.children}
+			</body>
+		</html>
+	`;
+}, "Layout");
+
+// src/decorators/controller.decorator.ts
+function Controller(route = "", options = {}) {
+  return (target) => {
+    MetadataRegistry.setControllerPath(target, route);
+    MetadataRegistry.setControllerOptions(target, options);
+  };
+}
+__name(Controller, "Controller");
+
+// src/decorators/http-method.decorator.ts
+var Get = createHttpMethodDecorator("get");
+var Post = createHttpMethodDecorator("post");
+var Put = createHttpMethodDecorator("put");
+var Delete = createHttpMethodDecorator("delete");
+var Patch = createHttpMethodDecorator("patch");
+var Options = createHttpMethodDecorator("options");
+var All = createHttpMethodDecorator("all");
+
+// src/decorators/module.decorator.ts
+function Module(options = {}) {
+  return (target) => {
+    MetadataRegistry.setModuleOptions(target, options);
+  };
+}
+__name(Module, "Module");
+
+// src/decorators/mvc.decorator.ts
+function View(route = "", options = {
+  prefix: null,
+  version: null
+}) {
+  return Controller(route, options);
+}
+__name(View, "View");
+var Page = Get;
+function MvcModule(options = {}) {
+  return Module({
+    imports: options.imports,
+    services: options.services,
+    controllers: (options.views || []).concat(options.controllers || [])
+  });
+}
+__name(MvcModule, "MvcModule");
+
+// src/decorators/parameter.decorator.ts
+var Body = createParamDecorator("body", async (data, ctx) => {
+  let body = ctx.get(HONEST_PIPELINE_BODY_CACHE_KEY);
+  if (body === void 0) {
+    body = await ctx.req.json();
+    ctx.set(HONEST_PIPELINE_BODY_CACHE_KEY, body);
+  }
+  if (data && body && typeof body === "object") {
+    return body[String(data)];
+  }
+  return body;
+});
+var Param = createParamDecorator("param", (data, ctx) => {
+  return data ? ctx.req.param(String(data)) : ctx.req.param();
+});
+var Query = createParamDecorator("query", (data, ctx) => {
+  return data ? ctx.req.query(String(data)) : ctx.req.query();
+});
+var Header = createParamDecorator("header", (data, ctx) => {
+  return data ? ctx.req.header(String(data)) : ctx.req.header();
+});
+var Req = createParamDecorator("request", (_, ctx) => ctx.req);
+var Request = createParamDecorator("request", (_, ctx) => ctx.req);
+var Res = createParamDecorator("response", (_, ctx) => ctx.res);
+var Response2 = createParamDecorator("response", (_, ctx) => ctx.res);
+var Ctx = createParamDecorator("context", (_, ctx) => ctx);
+var Context = createParamDecorator("context", (_, ctx) => ctx);
+var Var = createParamDecorator("variable", (data, ctx) => data === void 0 ? void 0 : ctx.get(String(data)));
+var Variable = createParamDecorator("variable", (data, ctx) => data === void 0 ? void 0 : ctx.get(String(data)));
+
+// src/decorators/service.decorator.ts
+function Service() {
+  return (target) => {
+    MetadataRegistry.addService(target);
+  };
+}
+__name(Service, "Service");
+
+// src/decorators/use-component.decorator.ts
+function UseComponent(type, ...components) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const controllerClass = target.constructor;
+      components.forEach((component) => MetadataRegistry.registerHandler(type, controllerClass, propertyKey, component));
+    } else {
+      components.forEach((component) => MetadataRegistry.registerController(type, target, component));
+    }
+  };
+}
+__name(UseComponent, "UseComponent");
+
+// src/decorators/use-filters.decorator.ts
+function UseFilters(...filters) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const controllerClass = target.constructor;
+      filters.forEach((filter) => MetadataRegistry.registerHandler("filter", controllerClass, propertyKey, filter));
+    } else {
+      filters.forEach((filter) => MetadataRegistry.registerController("filter", target, filter));
+    }
+  };
+}
+__name(UseFilters, "UseFilters");
+
+// src/decorators/use-guards.decorator.ts
+function UseGuards(...guards) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const controllerClass = target.constructor;
+      guards.forEach((guard) => MetadataRegistry.registerHandler("guard", controllerClass, propertyKey, guard));
+    } else {
+      guards.forEach((guard) => MetadataRegistry.registerController("guard", target, guard));
+    }
+  };
+}
+__name(UseGuards, "UseGuards");
+
+// src/decorators/use-middleware.decorator.ts
+function UseMiddleware(...middleware) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const controllerClass = target.constructor;
+      middleware.forEach((mw) => MetadataRegistry.registerHandler("middleware", controllerClass, propertyKey, mw));
+    } else {
+      middleware.forEach((mw) => MetadataRegistry.registerController("middleware", target, mw));
+    }
+  };
+}
+__name(UseMiddleware, "UseMiddleware");
+
+// src/decorators/use-pipes.decorator.ts
+function UsePipes(...pipes) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const controllerClass = target.constructor;
+      pipes.forEach((pipe) => MetadataRegistry.registerHandler("pipe", controllerClass, propertyKey, pipe));
+    } else {
+      pipes.forEach((pipe) => MetadataRegistry.registerController("pipe", target, pipe));
+    }
+  };
+}
+__name(UsePipes, "UsePipes");
+
+// src/testing/create-testing-module.ts
+function createTestingModule(options = {}) {
+  const { controllers, services, imports, name = "TestModule" } = options;
+  const dynamicModule = {
+    [name]: class {
+    }
+  }[name];
+  Module({
+    controllers,
+    services,
+    imports
+  })(dynamicModule);
+  return dynamicModule;
+}
+__name(createTestingModule, "createTestingModule");
+
+// src/testing/create-test-application.ts
+async function createTestApplication(options = {}) {
+  const { module, appOptions, ...moduleOptions } = options;
+  const rootModule = module ?? createTestingModule(moduleOptions);
+  const { app, hono } = await Application.create(rootModule, appOptions);
+  const request = /* @__PURE__ */ __name((input, init) => {
+    if (typeof input === "string") {
+      const normalizedInput = input.startsWith("http://") || input.startsWith("https://") ? input : `http://localhost${input.startsWith("/") ? input : `/${input}`}`;
+      return Promise.resolve(hono.request(normalizedInput, init));
+    }
+    return Promise.resolve(hono.request(input));
+  }, "request");
+  return {
+    app,
+    hono,
+    request
+  };
+}
+__name(createTestApplication, "createTestApplication");
+
+// src/testing/create-controller-test-application.ts
+async function createControllerTestApplication(options) {
+  const { controller, ...rest } = options;
+  return createTestApplication({
+    ...rest,
+    controllers: [
+      controller
+    ]
+  });
+}
+__name(createControllerTestApplication, "createControllerTestApplication");
+
+// src/testing/create-service-test-container.ts
+function createServiceTestContainer(options = {}) {
+  const logger = options.logger ?? new NoopLogger();
+  const container = new Container(void 0, logger, Boolean(options.debugDi));
+  for (const override of options.overrides ?? []) {
+    const typedOverride = override;
+    container.register(typedOverride.provide, typedOverride.useValue);
+  }
+  for (const service of options.preload ?? []) {
+    container.resolve(service);
+  }
+  return {
+    container,
+    get(target) {
+      return container.resolve(target);
+    },
+    register(target, instance) {
+      container.register(target, instance);
+    },
+    has(target) {
+      return container.has(target);
+    },
+    clear() {
+      container.clear();
+    }
+  };
+}
+__name(createServiceTestContainer, "createServiceTestContainer");
+
+exports.All = All;
+exports.Application = Application;
+exports.ApplicationContext = ApplicationContext;
+exports.Body = Body;
+exports.ConsoleLogger = ConsoleLogger;
+exports.Container = Container;
+exports.Context = Context;
+exports.Controller = Controller;
+exports.Ctx = Ctx;
+exports.Delete = Delete;
+exports.ErrorHandler = ErrorHandler;
+exports.FrameworkError = FrameworkError;
+exports.Get = Get;
+exports.HONEST_PIPELINE_BODY_CACHE_KEY = HONEST_PIPELINE_BODY_CACHE_KEY;
+exports.HONEST_PIPELINE_CONTROLLER_KEY = HONEST_PIPELINE_CONTROLLER_KEY;
+exports.HONEST_PIPELINE_HANDLER_KEY = HONEST_PIPELINE_HANDLER_KEY;
+exports.Header = Header;
+exports.Layout = Layout;
+exports.MetadataRegistry = MetadataRegistry;
+exports.MetadataRepository = MetadataRepository;
+exports.Module = Module;
+exports.MvcModule = MvcModule;
+exports.NoopLogger = NoopLogger;
+exports.NotFoundHandler = NotFoundHandler;
+exports.Options = Options;
+exports.Page = Page;
+exports.Param = Param;
+exports.Patch = Patch;
+exports.Post = Post;
+exports.Put = Put;
+exports.Query = Query;
+exports.Req = Req;
+exports.Request = Request;
+exports.Res = Res;
+exports.Response = Response2;
+exports.RouteRegistry = RouteRegistry;
+exports.Service = Service;
+exports.StaticServiceRegistry = StaticServiceRegistry;
+exports.UseComponent = UseComponent;
+exports.UseFilters = UseFilters;
+exports.UseGuards = UseGuards;
+exports.UseMiddleware = UseMiddleware;
+exports.UsePipes = UsePipes;
+exports.VERSION_NEUTRAL = VERSION_NEUTRAL;
+exports.Var = Var;
+exports.Variable = Variable;
+exports.View = View;
+exports.addLeadingSlash = addLeadingSlash;
+exports.createControllerTestApplication = createControllerTestApplication;
+exports.createErrorResponse = createErrorResponse;
+exports.createHttpMethodDecorator = createHttpMethodDecorator;
+exports.createParamDecorator = createParamDecorator;
+exports.createServiceTestContainer = createServiceTestContainer;
+exports.createTestApplication = createTestApplication;
+exports.createTestingModule = createTestingModule;
+exports.isConstructor = isConstructor;
+exports.isEmpty = isEmpty;
+exports.isFunction = isFunction;
+exports.isNil = isNil;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;
+exports.normalizePath = normalizePath;
+exports.stripEndSlash = stripEndSlash;