@nextrush/class 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,2371 @@
+import { InternalServerError, BadRequestError, ForbiddenError } from '@nextrush/errors';
+export { HttpError } from '@nextrush/errors';
+import { readdir } from 'node:fs/promises';
+import { resolve, join, sep, extname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import 'reflect-metadata';
+import { markInjectable, createContainer, container, hasServiceMetadata, getServiceScope, getOptionalParams, DIError } from '@nextrush/di';
+export { Repository, Service, container, createContainer, inject } from '@nextrush/di';
+import { ROUTE_METADATA } from '@nextrush/types';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/metadata/metadata-keys.ts
+function isValidHttpMethod(method) {
+  return [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "HEAD",
+    "OPTIONS",
+    "ALL"
+  ].includes(method);
+}
+function isValidParamSource(source) {
+  return [
+    "body",
+    "query",
+    "param",
+    "header",
+    "ctx",
+    "req",
+    "res",
+    "custom"
+  ].includes(source);
+}
+function isGuardClass(guard) {
+  if (typeof guard !== "function") {
+    return false;
+  }
+  const proto = guard.prototype;
+  if (!proto || typeof proto !== "object") {
+    return false;
+  }
+  return typeof proto.canActivate === "function";
+}
+var DECORATOR_METADATA_KEYS;
+var init_metadata_keys = __esm({
+  "src/metadata/metadata-keys.ts"() {
+    DECORATOR_METADATA_KEYS = {
+      CONTROLLER: /* @__PURE__ */ Symbol.for("nextrush:controller"),
+      MODULE: /* @__PURE__ */ Symbol.for("nextrush:module"),
+      ROUTES: /* @__PURE__ */ Symbol.for("nextrush:routes"),
+      PARAMS: /* @__PURE__ */ Symbol.for("nextrush:params"),
+      MIDDLEWARE: /* @__PURE__ */ Symbol.for("nextrush:middleware"),
+      GUARDS: /* @__PURE__ */ Symbol.for("nextrush:guards"),
+      INTERCEPTORS: /* @__PURE__ */ Symbol.for("nextrush:interceptors"),
+      FILTERS: /* @__PURE__ */ Symbol.for("nextrush:filters"),
+      CATCH: /* @__PURE__ */ Symbol.for("nextrush:catch"),
+      RESPONSE_HEADERS: /* @__PURE__ */ Symbol.for("nextrush:response-headers"),
+      REDIRECT: /* @__PURE__ */ Symbol.for("nextrush:redirect"),
+      HTTP_CODE: /* @__PURE__ */ Symbol.for("nextrush:http-code")
+    };
+    __name(isValidHttpMethod, "isValidHttpMethod");
+    __name(isValidParamSource, "isValidParamSource");
+    __name(isGuardClass, "isGuardClass");
+  }
+});
+
+// src/lifecycle/lifecycle-types.ts
+function isOnInit(value) {
+  return typeof value === "object" && value !== null && typeof value.onInit === "function";
+}
+function isOnShutdown(value) {
+  return typeof value === "object" && value !== null && typeof value.onShutdown === "function";
+}
+var init_lifecycle_types = __esm({
+  "src/lifecycle/lifecycle-types.ts"() {
+    __name(isOnInit, "isOnInit");
+    __name(isOnShutdown, "isOnShutdown");
+  }
+});
+
+// src/types.ts
+var init_types = __esm({
+  "src/types.ts"() {
+    init_metadata_keys();
+  }
+});
+
+// src/reflection/reflection.ts
+function getConstructorParamTypes(target) {
+  const DESIGN_PARAMTYPES = "design:paramtypes";
+  return Reflect.getMetadata(DESIGN_PARAMTYPES, target) ?? [];
+}
+function getMetadata(key, target, propertyKey) {
+  if (propertyKey !== void 0) {
+    return Reflect.getMetadata(key, target, propertyKey);
+  }
+  return Reflect.getMetadata(key, target);
+}
+function getOwnMetadata(key, target) {
+  return Reflect.getOwnMetadata(key, target);
+}
+function defineMetadata(key, value, target, propertyKey) {
+  if (propertyKey !== void 0) {
+    Reflect.defineMetadata(key, value, target, propertyKey);
+  } else {
+    Reflect.defineMetadata(key, value, target);
+  }
+}
+function hasOwnMetadata(key, target) {
+  return Reflect.hasOwnMetadata(key, target);
+}
+var init_reflection = __esm({
+  "src/reflection/reflection.ts"() {
+    __name(getConstructorParamTypes, "getConstructorParamTypes");
+    __name(getMetadata, "getMetadata");
+    __name(getOwnMetadata, "getOwnMetadata");
+    __name(defineMetadata, "defineMetadata");
+    __name(hasOwnMetadata, "hasOwnMetadata");
+  }
+});
+
+// src/metadata/metadata.ts
+function isController(target) {
+  return getOwnMetadata(DECORATOR_METADATA_KEYS.CONTROLLER, target) !== void 0;
+}
+function getControllerMetadata(target) {
+  const meta = getOwnMetadata(DECORATOR_METADATA_KEYS.CONTROLLER, target);
+  return meta ? {
+    ...meta
+  } : void 0;
+}
+function getRouteMetadata(target) {
+  const routes = getOwnMetadata(DECORATOR_METADATA_KEYS.ROUTES, target);
+  return routes ? [
+    ...routes
+  ] : [];
+}
+function getParamMetadata(target, methodName) {
+  const allParams = getOwnMetadata(DECORATOR_METADATA_KEYS.PARAMS, target);
+  const params = allParams?.get(String(methodName));
+  return params ? [
+    ...params
+  ] : [];
+}
+function getAllParamMetadata(target) {
+  const params = getOwnMetadata(DECORATOR_METADATA_KEYS.PARAMS, target);
+  if (!params) return /* @__PURE__ */ new Map();
+  const copy = /* @__PURE__ */ new Map();
+  for (const [key, value] of params) {
+    copy.set(key, [
+      ...value
+    ]);
+  }
+  return copy;
+}
+function getControllerDefinition(target) {
+  const controller = getControllerMetadata(target);
+  if (!controller) {
+    return void 0;
+  }
+  return {
+    target,
+    controller,
+    routes: getRouteMetadata(target),
+    params: getAllParamMetadata(target)
+  };
+}
+function getResponseHeaders(target, methodName) {
+  const map = getOwnMetadata(DECORATOR_METADATA_KEYS.RESPONSE_HEADERS, target);
+  return [
+    ...map?.get(methodName) ?? []
+  ];
+}
+function getRedirectMetadata(target, methodName) {
+  const map = getOwnMetadata(DECORATOR_METADATA_KEYS.REDIRECT, target);
+  return map?.get(methodName);
+}
+function getHttpCode(target, methodName) {
+  const map = getOwnMetadata(DECORATOR_METADATA_KEYS.HTTP_CODE, target);
+  return map?.get(methodName);
+}
+var init_metadata = __esm({
+  "src/metadata/metadata.ts"() {
+    init_types();
+    init_reflection();
+    __name(isController, "isController");
+    __name(getControllerMetadata, "getControllerMetadata");
+    __name(getRouteMetadata, "getRouteMetadata");
+    __name(getParamMetadata, "getParamMetadata");
+    __name(getAllParamMetadata, "getAllParamMetadata");
+    __name(getControllerDefinition, "getControllerDefinition");
+    __name(getResponseHeaders, "getResponseHeaders");
+    __name(getRedirectMetadata, "getRedirectMetadata");
+    __name(getHttpCode, "getHttpCode");
+  }
+});
+var ControllerError, NotAControllerError, NoRoutesError, DiscoveryError, ControllerResolutionError, ParameterInjectionError, MissingParameterError, RouteRegistrationError, GuardRejectionError, NotAModuleError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    ControllerError = class extends InternalServerError {
+      static {
+        __name(this, "ControllerError");
+      }
+      constructor(message, code, options) {
+        super(message, {
+          code,
+          ...options
+        });
+        this.name = "ControllerError";
+      }
+    };
+    NotAControllerError = class extends ControllerError {
+      static {
+        __name(this, "NotAControllerError");
+      }
+      constructor(className) {
+        super(`Class "${className}" is not a controller.
+
+To make it a controller, add the @Controller decorator:
+
+  import { Controller } from '@nextrush/class';
+
+  @Controller('/path')
+  class ${className} {
+    // ...
+  }
+`, "NOT_A_CONTROLLER");
+        this.name = "NotAControllerError";
+      }
+    };
+    NoRoutesError = class extends ControllerError {
+      static {
+        __name(this, "NoRoutesError");
+      }
+      constructor(className) {
+        super(`Controller "${className}" has no routes defined.
+
+Add route decorators to your controller methods:
+
+  import { Controller, Get, Post } from '@nextrush/class';
+
+  @Controller('/users')
+  class ${className} {
+    @Get()
+    findAll() { }
+
+    @Post()
+    create(@Body() data: CreateDto) { }
+  }
+`, "NO_ROUTES");
+        this.name = "NoRoutesError";
+      }
+    };
+    DiscoveryError = class extends ControllerError {
+      static {
+        __name(this, "DiscoveryError");
+      }
+      filePath;
+      constructor(filePath, reason, cause) {
+        super(`Failed to discover controllers in "${filePath}".
+
+Reason: ${reason}
+
+Possible fixes:
+  1. Ensure the file exists and is accessible
+  2. Check for syntax errors in the file
+  3. Verify the file exports controller classes
+`, "DISCOVERY_ERROR", {
+          cause
+        });
+        this.name = "DiscoveryError";
+        this.filePath = filePath;
+      }
+    };
+    ControllerResolutionError = class extends ControllerError {
+      static {
+        __name(this, "ControllerResolutionError");
+      }
+      controllerName;
+      constructor(controllerName, cause) {
+        super(`Failed to resolve controller "${controllerName}" from DI container.
+
+Possible causes:
+  1. Controller is not registered in the DI container
+  2. Controller has unresolvable dependencies
+  3. Circular dependency detected
+
+Note: @Controller automatically registers with DI - no @Service() needed!
+
+  import { Controller } from '@nextrush/class';
+
+  @Controller('/path')
+  class ${controllerName} {
+    constructor(private readonly service: SomeService) { }
+  }
+`, "CONTROLLER_RESOLUTION_ERROR", {
+          cause
+        });
+        this.name = "ControllerResolutionError";
+        this.controllerName = controllerName;
+      }
+    };
+    ParameterInjectionError = class extends BadRequestError {
+      static {
+        __name(this, "ParameterInjectionError");
+      }
+      controllerName;
+      methodName;
+      paramIndex;
+      constructor(controllerName, methodName, paramIndex, reason) {
+        super(`Invalid parameter at index ${paramIndex} for "${controllerName}.${methodName}": ${reason}`, {
+          code: "PARAMETER_INJECTION_ERROR",
+          details: {
+            controller: controllerName,
+            method: methodName,
+            parameterIndex: paramIndex,
+            reason
+          }
+        });
+        this.name = "ParameterInjectionError";
+        this.controllerName = controllerName;
+        this.methodName = methodName;
+        this.paramIndex = paramIndex;
+      }
+    };
+    MissingParameterError = class extends BadRequestError {
+      static {
+        __name(this, "MissingParameterError");
+      }
+      controllerName;
+      methodName;
+      paramName;
+      source;
+      constructor(controllerName, methodName, paramName, source, messageOverride) {
+        super(messageOverride ?? `Required ${source} parameter "${paramName}" is missing`, {
+          code: "MISSING_PARAMETER",
+          details: {
+            parameter: paramName,
+            source,
+            controller: controllerName,
+            method: methodName
+          }
+        });
+        this.name = "MissingParameterError";
+        this.controllerName = controllerName;
+        this.methodName = methodName;
+        this.paramName = paramName;
+        this.source = source;
+      }
+    };
+    RouteRegistrationError = class extends ControllerError {
+      static {
+        __name(this, "RouteRegistrationError");
+      }
+      controllerName;
+      method;
+      path;
+      constructor(controllerName, method, path, reason, cause) {
+        super(`Failed to register route ${method} ${path} from controller "${controllerName}".
+
+Reason: ${reason}
+`, "ROUTE_REGISTRATION_ERROR", {
+          cause
+        });
+        this.name = "RouteRegistrationError";
+        this.controllerName = controllerName;
+        this.method = method;
+        this.path = path;
+      }
+    };
+    GuardRejectionError = class extends ForbiddenError {
+      static {
+        __name(this, "GuardRejectionError");
+      }
+      guardName;
+      constructor(guardName, message) {
+        super(message ?? "Access denied", {
+          code: "GUARD_REJECTED"
+        });
+        this.name = "GuardRejectionError";
+        this.guardName = guardName;
+      }
+    };
+    NotAModuleError = class extends ControllerError {
+      static {
+        __name(this, "NotAModuleError");
+      }
+      constructor(className) {
+        super(`Class "${className}" is not a module.
+
+To make it a module, add the @Module decorator:
+
+  import { Module } from '@nextrush/class';
+
+  @Module({
+    controllers: [SomeController],
+    providers: [SomeService],
+  })
+  class ${className} {}
+`, "NOT_A_MODULE");
+        this.name = "NotAModuleError";
+      }
+    };
+  }
+});
+
+// src/discovery/discovery.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  DEFAULT_EXCLUDE: () => DEFAULT_EXCLUDE,
+  DEFAULT_INCLUDE: () => DEFAULT_INCLUDE,
+  discoverControllers: () => discoverControllers,
+  getControllersFromResults: () => getControllersFromResults,
+  getErrorsFromResults: () => getErrorsFromResults
+});
+function matchesPattern(filename, patterns) {
+  return patterns.some((pattern) => {
+    let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(.*\\/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(filename);
+  });
+}
+function shouldInclude(relativePath, includePatterns, excludePatterns) {
+  if (matchesPattern(relativePath, excludePatterns)) {
+    return false;
+  }
+  return matchesPattern(relativePath, includePatterns);
+}
+async function scanDirectory(dir, rootDir, includePatterns, excludePatterns) {
+  const files = [];
+  try {
+    const entries = await readdir(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relativePath = fullPath.slice(rootDir.length + 1).split(sep).join("/");
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__" || entry.name.startsWith(".")) {
+          continue;
+        }
+        const subFiles = await scanDirectory(fullPath, rootDir, includePatterns, excludePatterns);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name);
+        if ((ext === ".ts" || ext === ".js") && !entry.name.endsWith(".d.ts")) {
+          if (shouldInclude(relativePath, includePatterns, excludePatterns)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return files;
+}
+async function importControllers(filePath, debug) {
+  const controllers = [];
+  const errors = [];
+  try {
+    const fileUrl = pathToFileURL(filePath).href;
+    const module = await import(fileUrl);
+    for (const exportName of Object.keys(module)) {
+      const exported = module[exportName];
+      if (typeof exported === "function" && isController(exported)) {
+        controllers.push(exported);
+        if (debug) {
+          process.stderr.write(`[Controllers] Discovered: ${exported.name} from ${filePath}
+`);
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(new DiscoveryError(filePath, error instanceof Error ? error.message : String(error), error instanceof Error ? error : void 0));
+  }
+  return {
+    controllers,
+    errors
+  };
+}
+async function discoverControllers(options) {
+  const rootDir = resolve(options.root);
+  const includePatterns = options.include ?? DEFAULT_INCLUDE;
+  const excludePatterns = options.exclude ?? DEFAULT_EXCLUDE;
+  const debug = options.debug ?? false;
+  if (debug) {
+    process.stderr.write(`[Controllers] Scanning: ${rootDir}
+`);
+    process.stderr.write(`[Controllers] Include: ${includePatterns.join(", ")}
+`);
+    process.stderr.write(`[Controllers] Exclude: ${excludePatterns.join(", ")}
+`);
+  }
+  const files = await scanDirectory(rootDir, rootDir, includePatterns, excludePatterns);
+  if (debug) {
+    process.stderr.write(`[Controllers] Found ${files.length} files to scan
+`);
+  }
+  const results = new Array(files.length);
+  let cursor = 0;
+  const worker = /* @__PURE__ */ __name(async () => {
+    for (let index = cursor++; index < files.length; index = cursor++) {
+      const filePath = files[index];
+      const { controllers, errors } = await importControllers(filePath, debug);
+      results[index] = {
+        filePath,
+        controllers,
+        errors
+      };
+    }
+  }, "worker");
+  const workerCount = Math.min(IMPORT_CONCURRENCY, files.length);
+  await Promise.all(Array.from({
+    length: workerCount
+  }, () => worker()));
+  return results;
+}
+function getControllersFromResults(results) {
+  const controllers = [];
+  for (const result of results) {
+    controllers.push(...result.controllers);
+  }
+  return controllers;
+}
+function getErrorsFromResults(results) {
+  const errors = [];
+  for (const result of results) {
+    errors.push(...result.errors);
+  }
+  return errors;
+}
+var DEFAULT_INCLUDE, DEFAULT_EXCLUDE, IMPORT_CONCURRENCY;
+var init_discovery = __esm({
+  "src/discovery/discovery.ts"() {
+    init_metadata();
+    init_errors();
+    DEFAULT_INCLUDE = [
+      "**/*.controller.ts",
+      "**/*.controller.js"
+    ];
+    DEFAULT_EXCLUDE = [
+      "**/*.test.ts",
+      "**/*.spec.ts",
+      "**/*.test.js",
+      "**/*.spec.js",
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/__tests__/**"
+    ];
+    IMPORT_CONCURRENCY = 16;
+    __name(matchesPattern, "matchesPattern");
+    __name(shouldInclude, "shouldInclude");
+    __name(scanDirectory, "scanDirectory");
+    __name(importControllers, "importControllers");
+    __name(discoverControllers, "discoverControllers");
+    __name(getControllersFromResults, "getControllersFromResults");
+    __name(getErrorsFromResults, "getErrorsFromResults");
+  }
+});
+
+// src/index.ts
+init_types();
+init_lifecycle_types();
+
+// src/decorators/class.ts
+init_reflection();
+
+// src/path-utils.ts
+function normalizePath(path, options = {}) {
+  let normalized = path.trim();
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (options.stripTrailingSlash && normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+__name(normalizePath, "normalizePath");
+
+// src/decorators/class.ts
+init_types();
+function Controller(pathOrOptions) {
+  return /* @__PURE__ */ __name(function controllerDecorator(target) {
+    const options = normalizeControllerOptions(pathOrOptions, target.name);
+    const metadata = {
+      path: options.path ?? "/",
+      version: options.version,
+      middleware: options.middleware,
+      tags: options.tags
+    };
+    defineMetadata(DECORATOR_METADATA_KEYS.CONTROLLER, metadata, target);
+    markInjectable(target);
+    return target;
+  }, "controllerDecorator");
+}
+__name(Controller, "Controller");
+function normalizeControllerOptions(input, className) {
+  if (typeof input === "string") {
+    return {
+      path: normalizePath(input, {
+        stripTrailingSlash: true
+      })
+    };
+  }
+  if (input && typeof input === "object") {
+    return {
+      ...input,
+      path: input.path ? normalizePath(input.path, {
+        stripTrailingSlash: true
+      }) : derivePathFromClassName(className)
+    };
+  }
+  return {
+    path: derivePathFromClassName(className)
+  };
+}
+__name(normalizeControllerOptions, "normalizeControllerOptions");
+function derivePathFromClassName(className) {
+  const baseName = className.replace(/Controller$/i, "");
+  if (!baseName) {
+    return "/";
+  }
+  const kebabCase = baseName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  return `/${kebabCase}`;
+}
+__name(derivePathFromClassName, "derivePathFromClassName");
+
+// src/modules/module.ts
+init_reflection();
+init_metadata_keys();
+function Module(options = {}) {
+  return /* @__PURE__ */ __name(function moduleDecorator(target) {
+    const metadata = {
+      imports: [
+        ...options.imports ?? []
+      ],
+      controllers: [
+        ...options.controllers ?? []
+      ],
+      providers: [
+        ...options.providers ?? []
+      ],
+      exports: [
+        ...options.exports ?? []
+      ]
+    };
+    defineMetadata(DECORATOR_METADATA_KEYS.MODULE, metadata, target);
+    markInjectable(target);
+    return target;
+  }, "moduleDecorator");
+}
+__name(Module, "Module");
+function isModule(target) {
+  return hasOwnMetadata(DECORATOR_METADATA_KEYS.MODULE, target);
+}
+__name(isModule, "isModule");
+function getModuleMetadata(target) {
+  const meta = getOwnMetadata(DECORATOR_METADATA_KEYS.MODULE, target);
+  if (!meta) {
+    return void 0;
+  }
+  return {
+    imports: [
+      ...meta.imports
+    ],
+    controllers: [
+      ...meta.controllers
+    ],
+    providers: [
+      ...meta.providers
+    ],
+    exports: [
+      ...meta.exports
+    ]
+  };
+}
+__name(getModuleMetadata, "getModuleMetadata");
+
+// src/decorators/http-code.ts
+init_reflection();
+init_types();
+function HttpCode(statusCode) {
+  return /* @__PURE__ */ __name(function httpCodeDecorator(target, propertyKey, descriptor) {
+    const methodKey = String(propertyKey);
+    const existing = getOwnMetadata(DECORATOR_METADATA_KEYS.HTTP_CODE, target.constructor) ?? /* @__PURE__ */ new Map();
+    existing.set(methodKey, statusCode);
+    defineMetadata(DECORATOR_METADATA_KEYS.HTTP_CODE, existing, target.constructor);
+    return descriptor;
+  }, "httpCodeDecorator");
+}
+__name(HttpCode, "HttpCode");
+
+// src/decorators/response-decorators.ts
+init_reflection();
+init_types();
+function SetHeader(name, value) {
+  return /* @__PURE__ */ __name(function setHeaderDecorator(target, propertyKey, descriptor) {
+    const methodKey = String(propertyKey);
+    const existing = getOwnMetadata(DECORATOR_METADATA_KEYS.RESPONSE_HEADERS, target.constructor) ?? /* @__PURE__ */ new Map();
+    const headers = existing.get(methodKey) ?? [];
+    headers.push({
+      name,
+      value
+    });
+    existing.set(methodKey, headers);
+    defineMetadata(DECORATOR_METADATA_KEYS.RESPONSE_HEADERS, existing, target.constructor);
+    return descriptor;
+  }, "setHeaderDecorator");
+}
+__name(SetHeader, "SetHeader");
+function Redirect(url, statusCode = 302) {
+  return /* @__PURE__ */ __name(function redirectDecorator(target, propertyKey, descriptor) {
+    const methodKey = String(propertyKey);
+    const existing = getOwnMetadata(DECORATOR_METADATA_KEYS.REDIRECT, target.constructor) ?? /* @__PURE__ */ new Map();
+    existing.set(methodKey, {
+      url,
+      statusCode
+    });
+    defineMetadata(DECORATOR_METADATA_KEYS.REDIRECT, existing, target.constructor);
+    return descriptor;
+  }, "redirectDecorator");
+}
+__name(Redirect, "Redirect");
+
+// src/decorators/routes.ts
+init_reflection();
+init_types();
+function createRouteDecorator(method) {
+  return /* @__PURE__ */ __name(function routeDecoratorFactory(pathOrOptions, options) {
+    return /* @__PURE__ */ __name(function routeDecorator(target, propertyKey, descriptor) {
+      const { path, routeOptions } = normalizeRouteInput(pathOrOptions, options);
+      const metadata = {
+        method,
+        path,
+        methodName: propertyKey,
+        propertyKey,
+        middleware: routeOptions?.middleware,
+        statusCode: routeOptions?.statusCode,
+        description: routeOptions?.description,
+        deprecated: routeOptions?.deprecated
+      };
+      const existingRoutes = getOwnMetadata(DECORATOR_METADATA_KEYS.ROUTES, target.constructor) ?? [];
+      defineMetadata(DECORATOR_METADATA_KEYS.ROUTES, [
+        ...existingRoutes,
+        metadata
+      ], target.constructor);
+      return descriptor;
+    }, "routeDecorator");
+  }, "routeDecoratorFactory");
+}
+__name(createRouteDecorator, "createRouteDecorator");
+function normalizeRouteInput(pathOrOptions, options) {
+  if (typeof pathOrOptions === "string") {
+    return {
+      path: normalizePath(pathOrOptions),
+      routeOptions: options
+    };
+  }
+  if (pathOrOptions && typeof pathOrOptions === "object") {
+    const path = pathOrOptions.path ? normalizePath(pathOrOptions.path) : "/";
+    return {
+      path,
+      routeOptions: pathOrOptions
+    };
+  }
+  return {
+    path: "/",
+    routeOptions: options
+  };
+}
+__name(normalizeRouteInput, "normalizeRouteInput");
+var Get = createRouteDecorator("GET");
+var Post = createRouteDecorator("POST");
+var Put = createRouteDecorator("PUT");
+var Delete = createRouteDecorator("DELETE");
+var Patch = createRouteDecorator("PATCH");
+var Head = createRouteDecorator("HEAD");
+var Options = createRouteDecorator("OPTIONS");
+var All = createRouteDecorator("ALL");
+
+// src/binding/param-factory.ts
+init_types();
+init_reflection();
+function createParamDecorator(source, defaultRequired) {
+  return /* @__PURE__ */ __name(function paramDecoratorFactory(nameOrOptions, options) {
+    return /* @__PURE__ */ __name(function paramDecorator(target, propertyKey, parameterIndex) {
+      if (propertyKey === void 0) {
+        throw new Error(`Parameter decorator @${source.charAt(0).toUpperCase() + source.slice(1)} can only be used on method parameters, not constructor parameters.`);
+      }
+      const { name, paramOptions } = normalizeParamInput(nameOrOptions, options, source);
+      const metadata = {
+        source,
+        index: parameterIndex,
+        name,
+        required: paramOptions?.required ?? defaultRequired,
+        defaultValue: paramOptions?.defaultValue,
+        transform: paramOptions?.transform
+      };
+      pushParamMetadata(target, propertyKey, metadata);
+    }, "paramDecorator");
+  }, "paramDecoratorFactory");
+}
+__name(createParamDecorator, "createParamDecorator");
+function normalizeParamInput(nameOrOptions, options, source) {
+  if (typeof nameOrOptions === "string") {
+    return {
+      name: nameOrOptions,
+      paramOptions: options
+    };
+  }
+  if (nameOrOptions && typeof nameOrOptions === "object") {
+    return {
+      paramOptions: nameOrOptions
+    };
+  }
+  if (source === "body" || source === "ctx" || source === "req" || source === "res") {
+    return {
+      paramOptions: options
+    };
+  }
+  return {
+    paramOptions: options
+  };
+}
+__name(normalizeParamInput, "normalizeParamInput");
+function pushParamMetadata(target, propertyKey, metadata) {
+  const methodKey = `${String(propertyKey)}`;
+  const existingParams = getOwnMetadata(DECORATOR_METADATA_KEYS.PARAMS, target.constructor) ?? /* @__PURE__ */ new Map();
+  const methodParams = existingParams.get(methodKey) ?? [];
+  methodParams.push(metadata);
+  existingParams.set(methodKey, methodParams);
+  defineMetadata(DECORATOR_METADATA_KEYS.PARAMS, existingParams, target.constructor);
+}
+__name(pushParamMetadata, "pushParamMetadata");
+
+// src/binding/param-decorators.ts
+var Body = createParamDecorator("body", true);
+var Param = createParamDecorator("param", true);
+var Query = createParamDecorator("query", false);
+var Header = createParamDecorator("header", false);
+function Ctx() {
+  return /* @__PURE__ */ __name(function ctxDecorator(target, propertyKey, parameterIndex) {
+    if (propertyKey === void 0) {
+      throw new Error("@Ctx can only be used on method parameters, not constructor parameters.");
+    }
+    const metadata = {
+      source: "ctx",
+      index: parameterIndex,
+      required: false
+    };
+    pushParamMetadata(target, propertyKey, metadata);
+  }, "ctxDecorator");
+}
+__name(Ctx, "Ctx");
+function Req() {
+  return /* @__PURE__ */ __name(function reqDecorator(target, propertyKey, parameterIndex) {
+    if (propertyKey === void 0) {
+      throw new Error("@Req can only be used on method parameters, not constructor parameters.");
+    }
+    const metadata = {
+      source: "req",
+      index: parameterIndex,
+      required: false
+    };
+    pushParamMetadata(target, propertyKey, metadata);
+  }, "reqDecorator");
+}
+__name(Req, "Req");
+function Res() {
+  return /* @__PURE__ */ __name(function resDecorator(target, propertyKey, parameterIndex) {
+    if (propertyKey === void 0) {
+      throw new Error("@Res can only be used on method parameters, not constructor parameters.");
+    }
+    const metadata = {
+      source: "res",
+      index: parameterIndex,
+      required: false
+    };
+    pushParamMetadata(target, propertyKey, metadata);
+  }, "resDecorator");
+}
+__name(Res, "Res");
+
+// src/binding/custom-param.ts
+init_types();
+init_reflection();
+function pushParamMetadata2(target, propertyKey, metadata) {
+  const methodKey = `${String(propertyKey)}`;
+  const existingParams = getOwnMetadata(DECORATOR_METADATA_KEYS.PARAMS, target.constructor) ?? /* @__PURE__ */ new Map();
+  const methodParams = existingParams.get(methodKey) ?? [];
+  methodParams.push(metadata);
+  existingParams.set(methodKey, methodParams);
+  defineMetadata(DECORATOR_METADATA_KEYS.PARAMS, existingParams, target.constructor);
+}
+__name(pushParamMetadata2, "pushParamMetadata");
+function createCustomParamDecorator(extractor, options) {
+  return /* @__PURE__ */ __name(function customParamDecorator(target, propertyKey, parameterIndex) {
+    if (propertyKey === void 0) {
+      throw new Error("Custom parameter decorator can only be used on method parameters, not constructor parameters.");
+    }
+    const metadata = {
+      source: "custom",
+      index: parameterIndex,
+      required: options?.required ?? false,
+      transform: options?.transform,
+      customExtractor: extractor
+    };
+    pushParamMetadata2(target, propertyKey, metadata);
+  }, "customParamDecorator");
+}
+__name(createCustomParamDecorator, "createCustomParamDecorator");
+
+// src/guards/guards.ts
+init_reflection();
+init_types();
+function UseGuard(...guards) {
+  return /* @__PURE__ */ __name(function guardDecorator(target, propertyKey, descriptor) {
+    if (propertyKey !== void 0 && descriptor !== void 0) {
+      const existingGuards = getMetadata(DECORATOR_METADATA_KEYS.GUARDS, target.constructor, propertyKey) ?? [];
+      const metadata = {
+        guards,
+        target: "method",
+        methodName: propertyKey
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.GUARDS, [
+        ...existingGuards,
+        metadata
+      ], target.constructor, propertyKey);
+    } else {
+      const existingGuards = getMetadata(DECORATOR_METADATA_KEYS.GUARDS, target) ?? [];
+      const metadata = {
+        guards,
+        target: "class"
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.GUARDS, [
+        ...existingGuards,
+        metadata
+      ], target);
+    }
+  }, "guardDecorator");
+}
+__name(UseGuard, "UseGuard");
+function getClassGuards(target) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.GUARDS, target) ?? [];
+  return metadata.flatMap((m) => m.guards);
+}
+__name(getClassGuards, "getClassGuards");
+function getMethodGuards(target, methodName) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.GUARDS, target, methodName) ?? [];
+  return metadata.flatMap((m) => m.guards);
+}
+__name(getMethodGuards, "getMethodGuards");
+function getAllGuards(target, methodName) {
+  const classGuards = getClassGuards(target);
+  const methodGuards = getMethodGuards(target, methodName);
+  return [
+    ...classGuards,
+    ...methodGuards
+  ];
+}
+__name(getAllGuards, "getAllGuards");
+
+// src/filters/filters.ts
+init_reflection();
+init_types();
+function Catch(...errorTypes) {
+  return /* @__PURE__ */ __name(function catchDecorator(target) {
+    defineMetadata(DECORATOR_METADATA_KEYS.CATCH, errorTypes, target);
+  }, "catchDecorator");
+}
+__name(Catch, "Catch");
+function UseFilter(...filters) {
+  return /* @__PURE__ */ __name(function filterDecorator(target, propertyKey, descriptor) {
+    if (propertyKey !== void 0 && descriptor !== void 0) {
+      const existing = getMetadata(DECORATOR_METADATA_KEYS.FILTERS, target.constructor, propertyKey) ?? [];
+      const metadata = {
+        filters,
+        target: "method",
+        methodName: propertyKey
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.FILTERS, [
+        ...existing,
+        metadata
+      ], target.constructor, propertyKey);
+    } else {
+      const existing = getMetadata(DECORATOR_METADATA_KEYS.FILTERS, target) ?? [];
+      const metadata = {
+        filters,
+        target: "class"
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.FILTERS, [
+        ...existing,
+        metadata
+      ], target);
+    }
+  }, "filterDecorator");
+}
+__name(UseFilter, "UseFilter");
+function getCatchTypes(target) {
+  return getMetadata(DECORATOR_METADATA_KEYS.CATCH, target) ?? [];
+}
+__name(getCatchTypes, "getCatchTypes");
+function getClassFilters(target) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.FILTERS, target) ?? [];
+  return metadata.flatMap((m) => m.filters);
+}
+__name(getClassFilters, "getClassFilters");
+function getMethodFilters(target, methodName) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.FILTERS, target, methodName) ?? [];
+  return metadata.flatMap((m) => m.filters);
+}
+__name(getMethodFilters, "getMethodFilters");
+function getAllFilters(target, methodName) {
+  const methodFilters = getMethodFilters(target, methodName);
+  const classFilters = getClassFilters(target);
+  return [
+    ...methodFilters,
+    ...classFilters
+  ];
+}
+__name(getAllFilters, "getAllFilters");
+
+// src/interceptors/interceptors.ts
+init_reflection();
+init_types();
+function UseInterceptor(...interceptors) {
+  return /* @__PURE__ */ __name(function interceptorDecorator(target, propertyKey, descriptor) {
+    if (propertyKey !== void 0 && descriptor !== void 0) {
+      const existing = getMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, target.constructor, propertyKey) ?? [];
+      const metadata = {
+        interceptors,
+        target: "method",
+        methodName: propertyKey
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, [
+        ...existing,
+        metadata
+      ], target.constructor, propertyKey);
+    } else {
+      const existing = getMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, target) ?? [];
+      const metadata = {
+        interceptors,
+        target: "class"
+      };
+      defineMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, [
+        ...existing,
+        metadata
+      ], target);
+    }
+  }, "interceptorDecorator");
+}
+__name(UseInterceptor, "UseInterceptor");
+function getClassInterceptors(target) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, target) ?? [];
+  return metadata.flatMap((m) => m.interceptors);
+}
+__name(getClassInterceptors, "getClassInterceptors");
+function getMethodInterceptors(target, methodName) {
+  const metadata = getMetadata(DECORATOR_METADATA_KEYS.INTERCEPTORS, target, methodName) ?? [];
+  return metadata.flatMap((m) => m.interceptors);
+}
+__name(getMethodInterceptors, "getMethodInterceptors");
+function getAllInterceptors(target, methodName) {
+  const classInterceptors = getClassInterceptors(target);
+  const methodInterceptors = getMethodInterceptors(target, methodName);
+  return [
+    ...classInterceptors,
+    ...methodInterceptors
+  ];
+}
+__name(getAllInterceptors, "getAllInterceptors");
+
+// src/index.ts
+init_metadata();
+init_reflection();
+
+// src/registrar/registrar.ts
+init_discovery();
+init_errors();
+
+// src/bootstrap/stages/discover.ts
+async function discoverStage(ctx) {
+  ctx.discoveredClasses = await ctx.source.discover();
+}
+__name(discoverStage, "discoverStage");
+
+// src/bootstrap/stages/metadata.ts
+init_metadata();
+function metadataStage(ctx) {
+  ctx.controllerDefinitions = ctx.discoveredClasses.map((cls) => {
+    const def = getControllerDefinition(cls);
+    if (!def) {
+      throw new Error(`Controller class ${cls.name} has no metadata. Did you apply @Controller?`);
+    }
+    return def;
+  });
+}
+__name(metadataStage, "metadataStage");
+
+// src/request/isolation.ts
+init_reflection();
+var TSYRINGE_INJECTION_TOKENS = "injectionTokens";
+function tokenOf(descriptor) {
+  if (descriptor !== null && typeof descriptor === "object" && "token" in descriptor) {
+    return descriptor.token;
+  }
+  return descriptor;
+}
+__name(tokenOf, "tokenOf");
+function collectDependencyClasses(target) {
+  const paramTypes = getConstructorParamTypes(target);
+  const injectionTokens = getOwnMetadata(TSYRINGE_INJECTION_TOKENS, target) ?? {};
+  const optional = getOptionalParams(target);
+  const indices = /* @__PURE__ */ new Set();
+  for (let i = 0; i < paramTypes.length; i++) {
+    indices.add(i);
+  }
+  for (const key of Object.keys(injectionTokens)) {
+    indices.add(Number(key));
+  }
+  const deps = [];
+  for (const index of indices) {
+    if (optional.has(index)) {
+      continue;
+    }
+    const explicit = injectionTokens[index];
+    const token = explicit !== void 0 ? tokenOf(explicit) : paramTypes[index];
+    if (typeof token === "function") {
+      deps.push(token);
+    }
+  }
+  return deps;
+}
+__name(collectDependencyClasses, "collectDependencyClasses");
+function collectServiceGraph(controllers) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  const queue = [];
+  for (const controller of controllers) {
+    for (const dep of collectDependencyClasses(controller)) {
+      queue.push(dep);
+    }
+  }
+  for (let head = 0; head < queue.length; head++) {
+    const dep = queue[head];
+    if (visited.has(dep)) {
+      continue;
+    }
+    visited.add(dep);
+    if (!hasServiceMetadata(dep)) {
+      continue;
+    }
+    result.push(dep);
+    for (const sub of collectDependencyClasses(dep)) {
+      queue.push(sub);
+    }
+  }
+  return result;
+}
+__name(collectServiceGraph, "collectServiceGraph");
+function registerServiceGraph(controllers, container2, effectiveScopes) {
+  for (const dep of collectServiceGraph(controllers)) {
+    const scope = effectiveScopes?.get(dep) ?? getServiceScope(dep) ?? "singleton";
+    const token = dep;
+    if (!container2.isRegistered(token)) {
+      container2.register(token, {
+        useClass: dep
+      }, {
+        scope
+      });
+    }
+  }
+}
+__name(registerServiceGraph, "registerServiceGraph");
+
+// src/request/scope.ts
+function isEffectivelyRequest(cls, cache, visiting) {
+  const cached = cache.get(cls);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (visiting.has(cls)) {
+    return false;
+  }
+  visiting.add(cls);
+  let request = getServiceScope(cls) === "request";
+  if (!request) {
+    for (const dep of collectDependencyClasses(cls)) {
+      if (hasServiceMetadata(dep) && isEffectivelyRequest(dep, cache, visiting)) {
+        request = true;
+        break;
+      }
+    }
+  }
+  visiting.delete(cls);
+  cache.set(cls, request);
+  return request;
+}
+__name(isEffectivelyRequest, "isEffectivelyRequest");
+function computeEffectiveScopes(controllers) {
+  const requestCache = /* @__PURE__ */ new Map();
+  const scopes = /* @__PURE__ */ new Map();
+  const reachable = new Set(controllers);
+  for (const service of collectServiceGraph(controllers)) {
+    reachable.add(service);
+  }
+  for (const cls of reachable) {
+    const request = isEffectivelyRequest(cls, requestCache, /* @__PURE__ */ new Set());
+    scopes.set(cls, request ? "request" : getServiceScope(cls));
+  }
+  return scopes;
+}
+__name(computeEffectiveScopes, "computeEffectiveScopes");
+function requestScopedClasses(scopes) {
+  const set = /* @__PURE__ */ new Set();
+  for (const [cls, scope] of scopes) {
+    if (scope === "request") {
+      set.add(cls);
+    }
+  }
+  return set;
+}
+__name(requestScopedClasses, "requestScopedClasses");
+function registerRequestScopedServices(container2, scopes) {
+  for (const [cls, scope] of scopes) {
+    if (scope !== "request" || !hasServiceMetadata(cls)) {
+      continue;
+    }
+    container2.register(cls, {
+      useClass: cls
+    }, {
+      scope: "request"
+    });
+  }
+}
+__name(registerRequestScopedServices, "registerRequestScopedServices");
+function bindRequestScopes(controllers, container2, isolate) {
+  const scopes = computeEffectiveScopes(controllers);
+  const requestScoped = requestScopedClasses(scopes);
+  if (isolate) {
+    registerServiceGraph(controllers, container2, scopes);
+  } else if (requestScoped.size > 0) {
+    registerRequestScopedServices(container2, scopes);
+  }
+  return requestScoped;
+}
+__name(bindRequestScopes, "bindRequestScopes");
+
+// src/bootstrap/stages/provider-graph.ts
+async function providerGraphStage(ctx) {
+  ctx.requestScoped = bindRequestScopes(ctx.discoveredClasses, ctx.resolvedOptions.container, ctx.resolvedOptions.isolate);
+  const graph = /* @__PURE__ */ new Map();
+  for (const cls of ctx.discoveredClasses) {
+    graph.set(cls, collectDependencyClasses(cls));
+  }
+  ctx.providerGraph = graph;
+}
+__name(providerGraphStage, "providerGraphStage");
+
+// src/bootstrap/stages/validation.ts
+async function validationStage(ctx) {
+  await ctx.resolvedOptions.container.bootstrap();
+}
+__name(validationStage, "validationStage");
+
+// src/registrar/registry.ts
+init_metadata();
+
+// src/runtime/handler.ts
+init_metadata();
+init_errors();
+
+// src/filters/filter-runner.ts
+function filterMatches(catchTypes, error) {
+  if (catchTypes.length === 0) {
+    return true;
+  }
+  return catchTypes.some((type) => error instanceof type);
+}
+__name(filterMatches, "filterMatches");
+async function applyFilters(filters, error, ctx, container2) {
+  for (const filter of filters) {
+    if (!filterMatches(getCatchTypes(filter), error)) {
+      continue;
+    }
+    const instance = container2.resolve(filter);
+    await instance.catch(error, ctx);
+    return true;
+  }
+  return false;
+}
+__name(applyFilters, "applyFilters");
+function wrapWithFilters(execute, filters, container2) {
+  return async (ctx, next) => {
+    try {
+      await execute(ctx, next);
+    } catch (error) {
+      const handled = await applyFilters(filters, error, ctx, container2);
+      if (!handled) {
+        throw error;
+      }
+    }
+  };
+}
+__name(wrapWithFilters, "wrapWithFilters");
+
+// src/guards/guard-runner.ts
+init_errors();
+async function executeGuards(guards, ctx, container2, _controllerName, _methodName) {
+  const guardContext = {
+    method: ctx.method,
+    path: ctx.path,
+    params: ctx.params,
+    query: ctx.query,
+    headers: ctx.headers,
+    body: ctx.body,
+    state: ctx.state,
+    get: /* @__PURE__ */ __name((name) => ctx.get(name), "get")
+  };
+  for (let i = 0; i < guards.length; i++) {
+    const guard = guards[i];
+    let guardName;
+    let result;
+    if (isGuardClass(guard)) {
+      guardName = guard.name || `ClassGuard[${i}]`;
+      const guardInstance = container2.resolve(guard);
+      result = await guardInstance.canActivate(guardContext);
+    } else {
+      guardName = guard.name || `Guard[${i}]`;
+      result = await guard(guardContext);
+    }
+    if (!result) {
+      throw new GuardRejectionError(guardName);
+    }
+  }
+}
+__name(executeGuards, "executeGuards");
+
+// src/interceptors/interceptor-runner.ts
+async function runInterceptors(interceptors, ctx, container2, invokeMethod) {
+  let next = invokeMethod;
+  for (let i = interceptors.length - 1; i >= 0; i--) {
+    const interceptorClass = interceptors[i];
+    const downstream = next;
+    next = /* @__PURE__ */ __name(() => {
+      const instance = container2.resolve(interceptorClass);
+      return instance.intercept(ctx, downstream);
+    }, "next");
+  }
+  return next();
+}
+__name(runInterceptors, "runInterceptors");
+
+// src/binding/param-resolver.ts
+init_errors();
+async function resolveParametersFromPlan(ctx, sortedMetadata, controllerName, methodName) {
+  if (sortedMetadata.length === 0) {
+    return [];
+  }
+  const maxIndex = sortedMetadata.length > 0 ? sortedMetadata[sortedMetadata.length - 1].index : -1;
+  const args = new Array(maxIndex + 1).fill(void 0);
+  for (const param of sortedMetadata) {
+    try {
+      const value = await extractParameterValue(ctx, param);
+      if (value === void 0) {
+        if (param.required && param.defaultValue === void 0) {
+          throw createMissingParameterError(controllerName, methodName, param.name ?? `index ${param.index}`, param.source);
+        }
+        args[param.index] = param.defaultValue;
+      } else {
+        args[param.index] = param.transform ? await param.transform(value) : value;
+      }
+    } catch (error) {
+      if (error instanceof MissingParameterError) {
+        throw error;
+      }
+      throw new ParameterInjectionError(controllerName, methodName, param.index, error instanceof Error ? error.message : String(error));
+    }
+  }
+  return args;
+}
+__name(resolveParametersFromPlan, "resolveParametersFromPlan");
+function createMissingParameterError(controllerName, methodName, paramName, source) {
+  const messageOverride = source === "body" ? `Required body parameter "${paramName}" is missing. No body was parsed for this request \u2014 register a body-parser middleware before this route (e.g. app.use(json()) from '@nextrush/body-parser').` : void 0;
+  return new MissingParameterError(controllerName, methodName, paramName, source, messageOverride);
+}
+__name(createMissingParameterError, "createMissingParameterError");
+function extractParameterValue(ctx, param) {
+  switch (param.source) {
+    case "body":
+      if (param.name) {
+        return ctx.body?.[param.name];
+      }
+      return ctx.body;
+    case "param":
+      if (param.name) {
+        return ctx.params[param.name];
+      }
+      return ctx.params;
+    case "query":
+      if (param.name) {
+        return ctx.query[param.name];
+      }
+      return ctx.query;
+    case "header":
+      if (param.name) {
+        return ctx.get(param.name);
+      }
+      return ctx.headers;
+    case "ctx":
+      return ctx;
+    case "req":
+      return ctx.raw.req;
+    case "res":
+      return ctx.raw.res;
+    case "custom":
+      if (param.customExtractor) {
+        return param.customExtractor(ctx);
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+__name(extractParameterValue, "extractParameterValue");
+
+// src/runtime/handler.ts
+function resolveMemoizedSingleton(controllerClass, container2, instanceCache) {
+  return () => {
+    if (!instanceCache.has(controllerClass)) {
+      try {
+        instanceCache.set(controllerClass, container2.resolve(controllerClass));
+      } catch (error) {
+        throw new ControllerResolutionError(controllerClass.name, error instanceof Error ? error : void 0);
+      }
+    }
+    return instanceCache.get(controllerClass);
+  };
+}
+__name(resolveMemoizedSingleton, "resolveMemoizedSingleton");
+function resolveFromRequestChild(controllerClass, container2) {
+  return () => {
+    try {
+      return container2.createChild().resolve(controllerClass);
+    } catch (error) {
+      throw new ControllerResolutionError(controllerClass.name, error instanceof Error ? error : void 0);
+    }
+  };
+}
+__name(resolveFromRequestChild, "resolveFromRequestChild");
+function createRouteHandler(controllerClass, route, container2, instanceCache, isRequestScoped = false) {
+  const methodName = String(route.methodName);
+  const paramMetadata = getParamMetadata(controllerClass, methodName);
+  const guards = getAllGuards(controllerClass, methodName);
+  const filters = getAllFilters(controllerClass, methodName);
+  const interceptors = getAllInterceptors(controllerClass, methodName);
+  const sortedParams = paramMetadata.length > 0 ? [
+    ...paramMetadata
+  ].sort((a, b) => a.index - b.index) : [];
+  const statusCode = route.statusCode;
+  const httpCode = getHttpCode(controllerClass, methodName);
+  const effectiveStatusCode = httpCode ?? statusCode;
+  const responseHeaders = getResponseHeaders(controllerClass, methodName);
+  const redirectMeta = getRedirectMetadata(controllerClass, methodName);
+  const resolveControllerInstance = isRequestScoped ? resolveFromRequestChild(controllerClass, container2) : resolveMemoizedSingleton(controllerClass, container2, instanceCache);
+  const execute = /* @__PURE__ */ __name(async (ctx) => {
+    if (guards.length > 0) {
+      await executeGuards(guards, ctx, container2, controllerClass.name);
+    }
+    const controllerInstance = resolveControllerInstance();
+    const args = await resolveParametersFromPlan(ctx, sortedParams, controllerClass.name, methodName);
+    const method = controllerInstance[methodName];
+    if (typeof method !== "function") {
+      throw new Error(`Method "${methodName}" not found on controller "${controllerClass.name}"`);
+    }
+    const invokeMethod = /* @__PURE__ */ __name(() => Promise.resolve(method.apply(controllerInstance, args)), "invokeMethod");
+    const result = interceptors.length > 0 ? await runInterceptors(interceptors, ctx, container2, invokeMethod) : await invokeMethod();
+    for (const header of responseHeaders) {
+      ctx.set(header.name, header.value);
+    }
+    if (effectiveStatusCode !== void 0) {
+      ctx.status = effectiveStatusCode;
+    }
+    if (redirectMeta && !ctx.responded) {
+      let redirectUrl = redirectMeta.url;
+      let redirectStatus = redirectMeta.statusCode;
+      if (typeof result === "string") {
+        redirectUrl = result;
+      } else if (result && typeof result === "object" && "url" in result) {
+        const override = result;
+        if (override.url) redirectUrl = override.url;
+        if (override.statusCode) redirectStatus = override.statusCode;
+      }
+      ctx.status = redirectStatus;
+      ctx.set("Location", redirectUrl);
+      ctx.send("");
+      return;
+    }
+    if (result !== void 0 && !ctx.responded) {
+      if (typeof result === "object") {
+        ctx.json(result);
+      } else {
+        ctx.send(String(result));
+      }
+    }
+  }, "execute");
+  return filters.length > 0 ? wrapWithFilters(execute, filters, container2) : execute;
+}
+__name(createRouteHandler, "createRouteHandler");
+
+// src/registrar/builder.ts
+function resolveMiddlewareRefs(refs, container2) {
+  return refs.map((ref) => {
+    if (typeof ref === "function") {
+      return ref;
+    }
+    const resolved = container2.resolve(ref);
+    if (typeof resolved !== "function") {
+      throw new Error(`Middleware token "${String(ref)}" resolved to a non-function value. Ensure the registered provider returns a middleware function.`);
+    }
+    return resolved;
+  });
+}
+__name(resolveMiddlewareRefs, "resolveMiddlewareRefs");
+function buildRoutes(definition, container2, globalPrefix, globalMiddleware, instanceCache = /* @__PURE__ */ new Map(), isRequestScoped = false) {
+  const routes = [];
+  const { target, controller, routes: routeMetadata } = definition;
+  for (const route of routeMetadata) {
+    const handler = createRouteHandler(target, route, container2, instanceCache, isRequestScoped);
+    const fullPath = buildFullRoutePath(globalPrefix, controller.path, route.path, controller.version);
+    const combinedMiddleware = [
+      ...globalMiddleware,
+      ...resolveMiddlewareRefs(controller.middleware ?? [], container2),
+      ...resolveMiddlewareRefs(route.middleware ?? [], container2)
+    ];
+    routes.push({
+      method: route.method,
+      path: fullPath,
+      handler,
+      middleware: combinedMiddleware,
+      controller: target,
+      methodName: String(route.methodName),
+      metadata: toRouteMetaContribution(controller, route)
+    });
+  }
+  return routes;
+}
+__name(buildRoutes, "buildRoutes");
+function toRouteMetaContribution(controller, route) {
+  const contribution = {};
+  if (route.description) {
+    contribution.description = route.description;
+  }
+  if (route.deprecated) {
+    contribution.deprecated = true;
+  }
+  if (controller.tags && controller.tags.length > 0) {
+    contribution.tags = [
+      ...controller.tags
+    ];
+  }
+  return Object.keys(contribution).length > 0 ? contribution : void 0;
+}
+__name(toRouteMetaContribution, "toRouteMetaContribution");
+function buildFullRoutePath(globalPrefix, controllerPath, routePath, version) {
+  const parts = [];
+  if (globalPrefix && globalPrefix !== "/") {
+    parts.push(globalPrefix.startsWith("/") ? globalPrefix : "/" + globalPrefix);
+  }
+  if (version) {
+    parts.push("/" + version);
+  }
+  if (controllerPath && controllerPath !== "/") {
+    parts.push(controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath);
+  }
+  if (routePath && routePath !== "/") {
+    parts.push(routePath.startsWith("/") ? routePath : "/" + routePath);
+  }
+  const fullPath = parts.join("") || "/";
+  return fullPath.replace(/\/+/g, "/");
+}
+__name(buildFullRoutePath, "buildFullRoutePath");
+
+// src/registrar/registry.ts
+init_errors();
+var ControllerRegistry = class {
+  static {
+    __name(this, "ControllerRegistry");
+  }
+  controllers = /* @__PURE__ */ new Map();
+  container;
+  globalPrefix;
+  globalMiddleware;
+  debug;
+  /**
+  * Classes whose effective DI scope is `'request'` (self or dependency graph
+  * declares `scope: 'request'`). A request-scoped controller is registered with
+  * the request lifecycle and resolved from a per-request child on every request
+  * instead of being memoized. Empty by default (pure singleton/transient graph).
+  */
+  requestScopedClasses;
+  /**
+  * Shared controller-instance cache, keyed by controller class.
+  *
+  * Owned by the registry so a single resolved singleton is reused across the
+  * boot-time eager validation (`validateControllers`) and the per-request
+  * handlers built by {@link buildRoutes}. Without a shared cache, `validate: true`
+  * resolves each controller twice: once at boot and again on the first request.
+  *
+  * A failed resolve is never stored, so resolution retries on each request until
+  * it succeeds (see `createRouteHandler` in `builder.ts`).
+  */
+  instanceCache = /* @__PURE__ */ new Map();
+  constructor(container2, globalPrefix, globalMiddleware, debug, requestScopedClasses2 = /* @__PURE__ */ new Set()) {
+    this.container = container2;
+    this.globalPrefix = globalPrefix;
+    this.globalMiddleware = globalMiddleware;
+    this.debug = debug;
+    this.requestScopedClasses = requestScopedClasses2;
+  }
+  /**
+  * Register a controller class
+  */
+  register(controllerClass) {
+    if (this.controllers.has(controllerClass)) {
+      return this.controllers.get(controllerClass);
+    }
+    if (!isController(controllerClass)) {
+      throw new NotAControllerError(controllerClass.name);
+    }
+    const definition = getControllerDefinition(controllerClass);
+    if (!definition) {
+      throw new NotAControllerError(controllerClass.name);
+    }
+    if (definition.routes.length === 0) {
+      throw new NoRoutesError(controllerClass.name);
+    }
+    this.registerInContainer(controllerClass);
+    const routes = buildRoutes(definition, this.container, this.globalPrefix, this.globalMiddleware, this.instanceCache, this.requestScopedClasses.has(controllerClass));
+    const registered = {
+      target: controllerClass,
+      definition,
+      routes
+    };
+    this.controllers.set(controllerClass, registered);
+    if (this.debug) {
+      this.logRegistration(registered);
+    }
+    return registered;
+  }
+  /**
+  * The shared controller-instance cache.
+  *
+  * Exposed so `registerControllers` can pre-seed it during eager validation
+  * (`validate: true`), making the boot-time resolve and the per-request handler
+  * share one singleton instead of resolving the same controller twice.
+  */
+  get instances() {
+    return this.instanceCache;
+  }
+  /**
+  * Register multiple controllers
+  */
+  registerAll(controllers) {
+    return controllers.map((c) => this.register(c));
+  }
+  /**
+  * Get all registered controllers
+  */
+  getAll() {
+    return Array.from(this.controllers.values());
+  }
+  /**
+  * Get all built routes from all controllers
+  */
+  getAllRoutes() {
+    const routes = [];
+    for (const controller of this.controllers.values()) {
+      routes.push(...controller.routes);
+    }
+    return routes;
+  }
+  /**
+  * Get total route count
+  */
+  get routeCount() {
+    let count = 0;
+    for (const controller of this.controllers.values()) {
+      count += controller.routes.length;
+    }
+    return count;
+  }
+  /**
+  * Check if a controller is registered
+  */
+  has(controllerClass) {
+    return this.controllers.has(controllerClass);
+  }
+  /**
+  * Clear all registrations
+  */
+  clear() {
+    this.controllers.clear();
+  }
+  /**
+  * Register the controller in the DI container with its effective scope: a
+  * request-effective controller (self or dependency graph declares
+  * `scope: 'request'`) uses the request (ContainerScoped) lifecycle so a fresh
+  * instance is built per request; every other controller stays a singleton.
+  */
+  registerInContainer(controllerClass) {
+    const token = controllerClass;
+    if (!this.container.isRegistered(token)) {
+      const scope = this.requestScopedClasses.has(controllerClass) ? "request" : "singleton";
+      this.container.register(token, {
+        useClass: token
+      }, {
+        scope
+      });
+    }
+  }
+  /**
+  * Log controller registration details
+  */
+  logRegistration(registered) {
+    const { target, routes } = registered;
+    process.stderr.write(`[Controllers] Registered: ${target.name}
+`);
+    for (const route of routes) {
+      process.stderr.write(`  ${route.method.padEnd(7)} ${route.path}
+`);
+    }
+  }
+};
+
+// src/bootstrap/stages/registrar.ts
+function registrarStage(ctx) {
+  const registry = new ControllerRegistry(ctx.resolvedOptions.container, ctx.resolvedOptions.prefix, ctx.resolvedOptions.middleware, ctx.resolvedOptions.debug, ctx.requestScoped);
+  const registered = registry.registerAll(ctx.discoveredClasses);
+  ctx.builtRoutes = [];
+  for (const regCtrl of registered) {
+    ctx.builtRoutes.push(...regCtrl.routes);
+  }
+  ctx.registryInstances = registry.instances;
+  ctx.lifecycleData.controllerClasses = ctx.discoveredClasses;
+  if (ctx.resolvedOptions.validate) {
+    validateControllers(registered, ctx.resolvedOptions.container, registry.instances);
+    validateGuards(registered, ctx.resolvedOptions.container);
+  }
+}
+__name(registrarStage, "registrarStage");
+
+// src/bootstrap/stages/router.ts
+init_errors();
+function routerStage(ctx) {
+  const router = ctx.router;
+  const routes = ctx.graph ? ctx.graph.routes : ctx.builtRoutes;
+  for (const route of routes) {
+    try {
+      const method = route.method.toLowerCase();
+      if (typeof router[method] !== "function") {
+        throw new RouteRegistrationError("Unknown", route.method, route.path, `Router does not support HTTP method: ${route.method}`);
+      }
+      const entries = buildRouteEntries(route);
+      router[method](route.path, ...entries);
+    } catch (error) {
+      throw new RouteRegistrationError("Unknown", route.method, route.path, error instanceof Error ? error.message : String(error), error instanceof Error ? error : void 0);
+    }
+  }
+}
+__name(routerStage, "routerStage");
+function buildRouteEntries(route) {
+  const entries = [
+    ...route.middleware
+  ];
+  if (route.metadata) {
+    entries.push({
+      [ROUTE_METADATA]: route.metadata
+    });
+  }
+  entries.push(route.handler);
+  return entries;
+}
+__name(buildRouteEntries, "buildRouteEntries");
+
+// src/lifecycle/lifecycle.ts
+init_lifecycle_types();
+var CONTROLLERS_LIFECYCLE_EXTENSION = "nextrush:controllers-lifecycle";
+var lifecycleRegistrationCount = 0;
+function collectLifecycleInstances(controllers, container2, instanceCache) {
+  const seen = /* @__PURE__ */ new Set();
+  const collected = [];
+  const consider = /* @__PURE__ */ __name((instance) => {
+    if (typeof instance !== "object" || instance === null || seen.has(instance)) {
+      return;
+    }
+    seen.add(instance);
+    if (isOnInit(instance) || isOnShutdown(instance)) {
+      collected.push(instance);
+    }
+  }, "consider");
+  for (const service of [
+    ...collectServiceGraph(controllers)
+  ].reverse()) {
+    try {
+      consider(container2.resolve(service));
+    } catch {
+      continue;
+    }
+  }
+  for (const controller of controllers) {
+    consider(instanceCache.get(controller));
+  }
+  return collected;
+}
+__name(collectLifecycleInstances, "collectLifecycleInstances");
+function registerLifecycleExtension(app, controllers, container2, instanceCache) {
+  const instances = collectLifecycleInstances(controllers, container2, instanceCache);
+  if (instances.length === 0) {
+    return;
+  }
+  if (app.isReady || app.isRunning) {
+    throw new Error("registerControllers() found services with lifecycle hooks (onInit/onShutdown), but the app is already booted (ready()) or running, so its configuration is frozen and the lifecycle Extension cannot be registered. Call registerControllers() BEFORE serve()/listen()/ready().");
+  }
+  app.extend({
+    name: `${CONTROLLERS_LIFECYCLE_EXTENSION}#${++lifecycleRegistrationCount}`,
+    async setup() {
+      for (const instance of instances) {
+        if (isOnInit(instance)) {
+          await instance.onInit();
+        }
+      }
+    },
+    async destroy() {
+      const errors = [];
+      for (const instance of [
+        ...instances
+      ].reverse()) {
+        if (isOnShutdown(instance)) {
+          try {
+            await instance.onShutdown();
+          } catch (err) {
+            errors.push(err);
+          }
+        }
+      }
+      if (errors.length > 0) {
+        throw new AggregateError(errors, `${String(errors.length)} onShutdown() hook(s) failed`);
+      }
+    }
+  });
+}
+__name(registerLifecycleExtension, "registerLifecycleExtension");
+
+// src/bootstrap/graph.ts
+function buildApplicationGraph(routes, providers, requestScopedTokens) {
+  return deepFreeze({
+    routes: [
+      ...routes
+    ],
+    providers,
+    requestScopedTokens
+  });
+}
+__name(buildApplicationGraph, "buildApplicationGraph");
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      deepFreeze(item);
+    }
+    return Object.freeze(obj);
+  }
+  if (obj instanceof Map) {
+    obj.forEach((value) => {
+      deepFreeze(value);
+    });
+    return Object.freeze(obj);
+  }
+  if (obj instanceof Set) {
+    obj.forEach((value) => {
+      deepFreeze(value);
+    });
+    return Object.freeze(obj);
+  }
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      deepFreeze(obj[key]);
+    }
+  }
+  return Object.freeze(obj);
+}
+__name(deepFreeze, "deepFreeze");
+
+// src/diagnostics/collector.ts
+function collectDiagnostics(graph, timings) {
+  const routes = graph.routes.map((route) => ({
+    method: route.method,
+    path: route.path,
+    controller: route.controller
+  }));
+  const providers = Array.from(graph.providers.entries()).map(([token, deps]) => ({
+    token,
+    dependencies: [
+      ...deps
+    ]
+  }));
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method}:${route.path}`;
+    routeMap.set(key, (routeMap.get(key) ?? 0) + 1);
+  }
+  const duplicateRoutes = Array.from(routeMap.entries()).filter(([_key, count]) => count > 1).map(([key, count]) => {
+    const [method, ...pathParts] = key.split(":");
+    return {
+      method,
+      path: pathParts.join(":"),
+      count
+    };
+  });
+  const circularDependencies = detectCircularDependencies(graph.providers);
+  return {
+    routes: Object.freeze(routes),
+    providers: Object.freeze(providers),
+    duplicateRoutes: Object.freeze(duplicateRoutes),
+    circularDependencies: Object.freeze(circularDependencies),
+    timings: Object.freeze(timings)
+  };
+}
+__name(collectDiagnostics, "collectDiagnostics");
+function detectCircularDependencies(providers) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((token, path) => {
+    if (recursionStack.has(token)) {
+      const cycleStart = path.indexOf(token);
+      if (cycleStart !== -1) {
+        const cycle = Object.freeze([
+          ...path.slice(cycleStart),
+          token
+        ]);
+        cycles.push({
+          cycle
+        });
+      }
+      return;
+    }
+    if (visited.has(token)) {
+      return;
+    }
+    visited.add(token);
+    recursionStack.add(token);
+    const deps = providers.get(token) || [];
+    for (const dep of deps) {
+      visit(dep, [
+        ...path,
+        token
+      ]);
+    }
+    recursionStack.delete(token);
+  }, "visit");
+  for (const token of providers.keys()) {
+    if (!visited.has(token)) {
+      visit(token, []);
+    }
+  }
+  return cycles;
+}
+__name(detectCircularDependencies, "detectCircularDependencies");
+
+// src/bootstrap/pipeline.ts
+async function bootstrapPipeline(ctx) {
+  const enableTiming = ctx.resolvedOptions.diagnostics ?? false;
+  const now = enableTiming ? () => performance.now() : () => 0;
+  let stageStart = now();
+  await discoverStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "discover",
+      ms: performance.now() - stageStart
+    });
+  }
+  if (ctx.discoveredClasses.length === 0) {
+    return;
+  }
+  stageStart = now();
+  metadataStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "metadata",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  await providerGraphStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "providerGraph",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  await validationStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "validation",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  registrarStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "registrar",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  ctx.graph = buildApplicationGraph(ctx.builtRoutes, ctx.providerGraph, ctx.requestScoped);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "graph",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  routerStage(ctx);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "router",
+      ms: performance.now() - stageStart
+    });
+  }
+  stageStart = now();
+  registerLifecycleExtension(ctx.app, ctx.lifecycleData.controllerClasses, ctx.resolvedOptions.container, ctx.registryInstances);
+  if (enableTiming) {
+    ctx.timings.push({
+      stage: "lifecycle",
+      ms: performance.now() - stageStart
+    });
+  }
+  if (enableTiming && ctx.graph) {
+    const report = collectDiagnostics(ctx.graph, ctx.timings);
+    storeClassDiagnostics(ctx.app, report);
+  }
+}
+__name(bootstrapPipeline, "bootstrapPipeline");
+var diagnosticsStore = /* @__PURE__ */ new WeakMap();
+function storeClassDiagnostics(app, report) {
+  diagnosticsStore.set(app, report);
+}
+__name(storeClassDiagnostics, "storeClassDiagnostics");
+function getClassDiagnosticsInternal(app) {
+  return diagnosticsStore.get(app);
+}
+__name(getClassDiagnosticsInternal, "getClassDiagnosticsInternal");
+
+// src/discovery/source.ts
+var FilesystemSource = class {
+  static {
+    __name(this, "FilesystemSource");
+  }
+  root;
+  include;
+  exclude;
+  debug;
+  _discoveryErrors = [];
+  constructor(root, include, exclude, debug) {
+    this.root = root;
+    this.include = include;
+    this.exclude = exclude;
+    this.debug = debug;
+  }
+  async discover() {
+    const { discoverControllers: discoverControllers2, getControllersFromResults: getControllersFromResults2, getErrorsFromResults: getErrorsFromResults2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+    const results = await discoverControllers2({
+      root: this.root,
+      include: this.include,
+      exclude: this.exclude,
+      debug: this.debug
+    });
+    const controllers = getControllersFromResults2(results);
+    this._discoveryErrors = getErrorsFromResults2(results);
+    return controllers;
+  }
+  /**
+  * Access discovery errors, if any, after discover() completes.
+  * @internal
+  */
+  getDiscoveryErrors() {
+    return this._discoveryErrors;
+  }
+};
+var MemorySource = class {
+  static {
+    __name(this, "MemorySource");
+  }
+  controllers;
+  constructor(controllers) {
+    this.controllers = controllers;
+  }
+  discover() {
+    return this.controllers;
+  }
+};
+
+// src/registrar/registrar.ts
+function debugLog(debug, message) {
+  if (debug) {
+    process.stderr.write(`[Controllers] ${message}
+`);
+  }
+}
+__name(debugLog, "debugLog");
+function warnLog(message) {
+  process.stderr.write(`[Controllers] WARNING: ${message}
+`);
+}
+__name(warnLog, "warnLog");
+function resolveOptions(options, container2) {
+  return {
+    root: options.root ?? null,
+    include: options.include ?? DEFAULT_INCLUDE,
+    exclude: options.exclude ?? DEFAULT_EXCLUDE,
+    controllers: options.controllers ?? [],
+    container: container2,
+    middleware: options.middleware ?? [],
+    debug: options.debug ?? false,
+    prefix: options.prefix ?? "",
+    strict: options.strict ?? false,
+    validate: options.validate ?? true,
+    isolate: options.isolate ?? false,
+    diagnostics: options.diagnostics ?? false
+  };
+}
+__name(resolveOptions, "resolveOptions");
+function validateControllers(registered, container2, instanceCache) {
+  for (const controller of registered) {
+    const token = controller.target;
+    try {
+      instanceCache.set(token, container2.resolve(token));
+    } catch (error) {
+      if (error instanceof DIError) {
+        throw error;
+      }
+      throw new ControllerResolutionError(controller.target.name, error instanceof Error ? error : void 0);
+    }
+  }
+}
+__name(validateControllers, "validateControllers");
+function validateGuards(registered, container2) {
+  const resolved = /* @__PURE__ */ new Set();
+  for (const controller of registered) {
+    for (const route of controller.definition.routes) {
+      const guards = getAllGuards(controller.target, route.methodName);
+      for (const guard of guards) {
+        if (!isGuardClass(guard) || resolved.has(guard)) {
+          continue;
+        }
+        resolved.add(guard);
+        try {
+          container2.resolve(guard);
+        } catch (error) {
+          if (error instanceof DIError) {
+            throw error;
+          }
+          const guardName = guard.name || "AnonymousGuard";
+          throw new Error(`Failed to resolve guard "${guardName}" from the DI container (used by controller "${controller.target.name}").
+
+A class-based guard is resolved from DI on every request to a guarded route. Surfacing the failure here means an unresolvable or circular guard dependency fails at boot instead of as a 500 on the first request.
+
+Ensure "${guardName}" and all of its constructor dependencies are registered in the DI container.`, {
+            cause: error instanceof Error ? error : void 0
+          });
+        }
+      }
+    }
+  }
+}
+__name(validateGuards, "validateGuards");
+async function registerControllers(app, options = {}) {
+  const router = app.router;
+  if (!router) {
+    throw new Error("registerControllers() requires an app with a router. Create the app with `createApp()` from `nextrush`, or pass `{ router }` to `createApp()`.");
+  }
+  const container2 = options.container ?? (options.isolate ? createContainer() : app.container ?? container);
+  const resolvedOpts = resolveOptions(options, container2);
+  let source;
+  if (options.source) {
+    source = options.source;
+  } else if (resolvedOpts.root) {
+    source = new FilesystemSource(resolvedOpts.root, resolvedOpts.include, resolvedOpts.exclude, resolvedOpts.debug);
+  } else {
+    source = new MemorySource([
+      ...resolvedOpts.controllers
+    ]);
+  }
+  const ctx = {
+    app,
+    router,
+    resolvedOptions: resolvedOpts,
+    source,
+    discoveredClasses: [],
+    controllerDefinitions: [],
+    providerGraph: /* @__PURE__ */ new Map(),
+    requestScoped: /* @__PURE__ */ new Set(),
+    registryInstances: /* @__PURE__ */ new Map(),
+    builtRoutes: [],
+    graph: null,
+    lifecycleData: {
+      controllerClasses: []
+    },
+    timings: []
+  };
+  await bootstrapPipeline(ctx);
+  if (ctx.discoveredClasses.length === 0) {
+    warnLog("No controllers found. Check your root path or patterns.");
+    return;
+  }
+  debugLog(resolvedOpts.debug, `Registered ${ctx.builtRoutes.length} routes`);
+}
+__name(registerControllers, "registerControllers");
+
+// src/modules/module-graph.ts
+init_errors();
+function collectModuleGraph(root) {
+  const ordered = [];
+  const completed = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((mod) => {
+    if (completed.has(mod)) {
+      return;
+    }
+    if (visiting.has(mod)) {
+      return;
+    }
+    if (!isModule(mod)) {
+      throw new NotAModuleError(mod.name || "AnonymousModule");
+    }
+    visiting.add(mod);
+    const metadata = getModuleMetadata(mod);
+    for (const imported of metadata?.imports ?? []) {
+      visit(imported);
+    }
+    visiting.delete(mod);
+    completed.add(mod);
+    ordered.push(mod);
+  }, "visit");
+  visit(root);
+  return ordered;
+}
+__name(collectModuleGraph, "collectModuleGraph");
+function collectModuleControllers(modules) {
+  const controllers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    const metadata = getModuleMetadata(mod);
+    for (const controller of metadata?.controllers ?? []) {
+      if (!seen.has(controller)) {
+        seen.add(controller);
+        controllers.push(controller);
+      }
+    }
+  }
+  return controllers;
+}
+__name(collectModuleControllers, "collectModuleControllers");
+
+// src/modules/module-registrar.ts
+async function registerModule(app, rootModule, options = {}) {
+  const container2 = options.container ?? (options.isolate ? createContainer() : app.container ?? container);
+  const modules = collectModuleGraph(rootModule);
+  for (const mod of modules) {
+    const metadata = getModuleMetadata(mod);
+    for (const provider of metadata?.providers ?? []) {
+      registerProvider(provider, container2);
+    }
+  }
+  const controllers = collectModuleControllers(modules);
+  await registerControllers(app, {
+    ...options,
+    container: container2,
+    controllers
+  });
+}
+__name(registerModule, "registerModule");
+function registerProvider(provider, container2) {
+  if (typeof provider === "function") {
+    registerClassProvider(provider, container2);
+    return;
+  }
+  registerConfigProvider(provider, container2);
+}
+__name(registerProvider, "registerProvider");
+function registerClassProvider(target, container2) {
+  const token = target;
+  if (container2.isRegistered(token)) {
+    return;
+  }
+  const scope = hasServiceMetadata(target) ? getServiceScope(target) : "singleton";
+  container2.register(token, {
+    useClass: token
+  }, {
+    scope: scope ?? "singleton"
+  });
+}
+__name(registerClassProvider, "registerClassProvider");
+function registerConfigProvider(provider, container2) {
+  const { provide, scope } = provider;
+  if ("useValue" in provider) {
+    container2.register(provide, {
+      useValue: provider.useValue
+    });
+    return;
+  }
+  if (provider.useFactory) {
+    container2.register(provide, {
+      useFactory: provider.useFactory,
+      inject: provider.inject
+    }, {
+      scope: scope ?? "singleton"
+    });
+    return;
+  }
+  if (provider.useClass) {
+    container2.register(provide, {
+      useClass: provider.useClass
+    }, {
+      scope: scope ?? "singleton"
+    });
+    return;
+  }
+  throw new Error(`Invalid module provider for token "${String(provide)}": a provider config must set exactly one of "useValue", "useFactory", or "useClass".`);
+}
+__name(registerConfigProvider, "registerConfigProvider");
+
+// src/index.ts
+init_discovery();
+
+// src/diagnostics/get-diagnostics.ts
+function getClassDiagnostics(app) {
+  return getClassDiagnosticsInternal(app);
+}
+__name(getClassDiagnostics, "getClassDiagnostics");
+
+// src/index.ts
+init_errors();
+
+export { All, Body, Catch, Controller, ControllerError, ControllerRegistry, ControllerResolutionError, Ctx, DECORATOR_METADATA_KEYS, Delete, DiscoveryError, FilesystemSource, Get, GuardRejectionError, Head, Header, HttpCode, MemorySource, MissingParameterError, Module, NoRoutesError, NotAControllerError, NotAModuleError, Options, Param, ParameterInjectionError, Patch, Post, Put, Query, Redirect, Req, Res, RouteRegistrationError, SetHeader, UseFilter, UseGuard, UseInterceptor, buildRoutes, collectModuleControllers, collectModuleGraph, createCustomParamDecorator, discoverControllers, getAllFilters, getAllGuards, getAllInterceptors, getAllParamMetadata, getCatchTypes, getClassDiagnostics, getClassFilters, getClassGuards, getClassInterceptors, getConstructorParamTypes, getControllerDefinition, getControllerMetadata, getControllersFromResults, getErrorsFromResults, getHttpCode, getMethodFilters, getMethodGuards, getMethodInterceptors, getModuleMetadata, getParamMetadata, getRedirectMetadata, getResponseHeaders, getRouteMetadata, isController, isGuardClass, isModule, isOnInit, isOnShutdown, isValidHttpMethod, isValidParamSource, registerControllers, registerModule };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map