@stacksjs/bun-router 0.0.18 → 0.0.19

package/dist/index.js

@@ -64,48 +64,11 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-cgptvjdf.js";
+} from "./chunk-y3xq6wq6.js";
 import {
-  AuthenticationException,
-  AuthorizationException,
-  BindingBuilder,
-  BusinessLogicException,
-  CircuitBreakerOpenException,
-  CircularDependencyException,
-  ConfigurationException,
-  Container,
-  ContextualContainer,
-  DatabaseException,
-  DefaultServiceProviderManager,
-  EnvironmentManager,
-  ErrorFactory,
-  ExternalServiceException,
-  FileSystemException,
-  HandlerResolutionException,
-  InternalServerException,
-  MethodNotAllowedException,
-  MiddlewareConfigurationException,
-  ModelBindingException,
-  NotFoundException,
-  RateLimitException,
-  RouteConflictException,
-  RouteNotFoundException,
-  RouterErrorFactory,
-  RouterException,
-  ServiceUnavailableException,
-  TimeoutException,
-  ValidationException,
-  createContainer,
-  detectRouteConflicts,
-  findSimilarRoutes,
-  getContainer,
-  setContainer
-} from "./chunk-g3ybefhg.js";
-import {
-  __export,
-  __require
-} from "./chunk-1ahs68ys.js";
-
+  ValidationException
+} from "./chunk-a8p83068.js";
+import"./chunk-2mx7fq49.js";
 // src/auth.ts
 import { timingSafeEqual } from "crypto";
 function base64UrlEncode(str) {
@@ -247,1805 +210,128 @@ class ApiKeyManager {
     this.keys = new Map;
     this.options = {
       source: "header",
-      keyName: "X-API-Key",
-      keyPrefix: "bun_",
-      ...options
-    };
-  }
-  generateKey(owner, scopes = [], expiresIn) {
-    const key = `${this.options.keyPrefix}${this.randomString(32)}`;
-    this.keys.set(key, {
-      owner,
-      scopes,
-      expiresAt: expiresIn ? new Date(Date.now() + expiresIn * 1000) : undefined
-    });
-    return key;
-  }
-  validateKey(key, requiredScopes = []) {
-    const keyInfo = this.keys.get(key);
-    if (!keyInfo) {
-      return false;
-    }
-    if (keyInfo.expiresAt && keyInfo.expiresAt < new Date) {
-      return false;
-    }
-    if (requiredScopes.length > 0) {
-      return requiredScopes.every((scope) => keyInfo.scopes.includes(scope));
-    }
-    return true;
-  }
-  getKeyInfo(key) {
-    return this.keys.get(key) || null;
-  }
-  revokeKey(key) {
-    return this.keys.delete(key);
-  }
-  extractFromRequest(req) {
-    const { source, keyName } = this.options;
-    switch (source) {
-      case "header":
-        return req.headers.get(keyName || "X-API-Key") || null;
-      case "query":
-        return new URL(req.url).searchParams.get(keyName || "api_key") || null;
-      case "cookie":
-        if (req.cookies) {
-          const key = keyName || "api_key";
-          if (typeof req.cookies.get === "function") {
-            return req.cookies.get(key) || null;
-          }
-          return req.cookies[key] || null;
-        }
-        return null;
-      default:
-        return null;
-    }
-  }
-  randomString(length) {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    let result = "";
-    for (let i = 0;i < length; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-  }
-}
-
-class OAuth2Helper {
-  config;
-  constructor(config2) {
-    this.config = config2;
-  }
-  getAuthorizationUrl(additionalParams = {}) {
-    const params = new URLSearchParams({
-      client_id: this.config.clientId,
-      redirect_uri: this.config.redirectUri,
-      response_type: "code",
-      ...additionalParams
-    });
-    if (this.config.scope) {
-      params.set("scope", this.config.scope);
-    }
-    if (this.config.state) {
-      params.set("state", this.config.state);
-    }
-    return `${this.config.authorizeUrl}?${params.toString()}`;
-  }
-  async exchangeCodeForToken(code) {
-    const params = new URLSearchParams({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: this.config.redirectUri,
-      client_id: this.config.clientId,
-      client_secret: this.config.clientSecret
-    });
-    const response = await fetch(this.config.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: params.toString()
-    });
-    if (!response.ok) {
-      throw new Error(`OAuth token exchange failed: ${response.status} ${response.statusText}`);
-    }
-    return await response.json();
-  }
-  async refreshToken(refreshToken) {
-    const params = new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_id: this.config.clientId,
-      client_secret: this.config.clientSecret
-    });
-    const response = await fetch(this.config.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: params.toString()
-    });
-    if (!response.ok) {
-      throw new Error(`OAuth token refresh failed: ${response.status} ${response.statusText}`);
-    }
-    return await response.json();
-  }
-}
-var Auth = {
-  JWT,
-  ApiKeyManager,
-  OAuth2Helper
-};
-var auth_default = Auth;
-// src/errors/index.ts
-var exports_errors = {};
-__export(exports_errors, {
-  withCircuitBreaker: () => withCircuitBreaker,
-  globalCircuitBreakerRegistry: () => globalCircuitBreakerRegistry,
-  findSimilarRoutes: () => findSimilarRoutes,
-  detectRouteConflicts: () => detectRouteConflicts,
-  createGracefulDegradationMiddleware: () => createGracefulDegradationMiddleware,
-  createErrorReporting: () => createErrorReporting,
-  createCircuitBreakerMiddleware: () => createCircuitBreakerMiddleware,
-  createCircuitBreaker: () => createCircuitBreaker,
-  createAdvancedErrorHandler: () => createAdvancedErrorHandler,
-  circuitBreaker: () => circuitBreaker,
-  ValidationException: () => ValidationException,
-  TimeoutException: () => TimeoutException,
-  ServiceUnavailableException: () => ServiceUnavailableException,
-  ServiceHealthMonitor: () => ServiceHealthMonitor,
-  SentryReporter: () => SentryReporter,
-  RouterException: () => RouterException,
-  RouterErrorFactory: () => RouterErrorFactory,
-  RouteNotFoundException: () => RouteNotFoundException,
-  RouteConflictException: () => RouteConflictException,
-  RateLimitException: () => RateLimitException,
-  NotFoundException: () => NotFoundException,
-  ModelBindingException: () => ModelBindingException,
-  MiddlewareConfigurationException: () => MiddlewareConfigurationException,
-  MethodNotAllowedException: () => MethodNotAllowedException,
-  InternalServerException: () => InternalServerException,
-  HandlerResolutionException: () => HandlerResolutionException,
-  GracefulDegradationManager: () => GracefulDegradationManager,
-  FileSystemException: () => FileSystemException,
-  ExternalServiceException: () => ExternalServiceException,
-  ErrorReportingPresets: () => ErrorReportingPresets,
-  ErrorReportingManager: () => ErrorReportingManager,
-  ErrorFactory: () => ErrorFactory,
-  DegradationStrategies: () => DegradationStrategies,
-  DatabaseException: () => DatabaseException,
-  CustomReporter: () => CustomReporter,
-  ConfigurationException: () => ConfigurationException,
-  CircularDependencyException: () => CircularDependencyException,
-  CircuitBreakerRegistry: () => CircuitBreakerRegistry,
-  CircuitBreakerPresets: () => CircuitBreakerPresets,
-  CircuitBreakerOpenException: () => CircuitBreakerOpenException,
-  CircuitBreakerHttpClient: () => CircuitBreakerHttpClient,
-  CircuitBreaker: () => CircuitBreaker,
-  BusinessLogicException: () => BusinessLogicException,
-  BugsnagReporter: () => BugsnagReporter,
-  AuthorizationException: () => AuthorizationException,
-  AuthenticationException: () => AuthenticationException
-});
-
-// src/errors/circuit-breaker.ts
-class CircuitBreaker {
-  config;
-  state = "CLOSED";
-  metrics;
-  nextAttemptTime;
-  halfOpenCallCount = 0;
-  recentRequests = [];
-  constructor(config2) {
-    const defaults = {
-      failureThreshold: 5,
-      recoveryTimeout: 60000,
-      timeout: 30000,
-      monitoringPeriod: 60000,
-      minimumRequests: 10,
-      errorThresholdPercentage: 50,
-      halfOpenMaxCalls: 3,
-      resetTimeout: 60000
-    };
-    this.config = {
-      ...defaults,
-      ...config2
-    };
-    this.metrics = {
-      totalRequests: 0,
-      successfulRequests: 0,
-      failedRequests: 0,
-      timeouts: 0,
-      averageResponseTime: 0,
-      state: this.state,
-      consecutiveFailures: 0,
-      consecutiveSuccesses: 0
-    };
-    setInterval(() => this.cleanupOldRequests(), this.config.monitoringPeriod / 4).unref?.();
-  }
-  async execute(call) {
-    if (this.state === "OPEN") {
-      if (this.nextAttemptTime && new Date < this.nextAttemptTime) {
-        const error2 = new CircuitBreakerOpenException(this.config.name, this.nextAttemptTime, call.context);
-        if (call.fallback) {
-          try {
-            return await call.fallback();
-          } catch (fallbackError) {
-            console.error(fallbackError);
-          }
-        }
-        throw error2;
-      } else {
-        this.transitionToHalfOpen();
-      }
-    }
-    if (this.state === "HALF_OPEN" && this.halfOpenCallCount >= this.config.halfOpenMaxCalls) {
-      const error2 = new CircuitBreakerOpenException(this.config.name, this.nextAttemptTime || new Date(Date.now() + this.config.recoveryTimeout), call.context);
-      if (call.fallback) {
-        try {
-          return await call.fallback();
-        } catch (fallbackError) {
-          console.error(fallbackError);
-          throw error2;
-        }
-      }
-      throw error2;
-    }
-    const startTime = Date.now();
-    let result;
-    let error = null;
-    try {
-      if (this.state === "HALF_OPEN") {
-        this.halfOpenCallCount++;
-      }
-      const timeout = call.timeout || this.config.timeout;
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new TimeoutException(`Circuit breaker timeout for ${this.config.name}`, timeout, call.context));
-        }, timeout);
-      });
-      result = await Promise.race([call.execute(), timeoutPromise]);
-      this.onSuccess(Date.now() - startTime);
-      return result;
-    } catch (err) {
-      error = err;
-      this.onFailure(error, Date.now() - startTime);
-      if (call.fallback) {
-        try {
-          return await call.fallback();
-        } catch (fallbackError) {
-          console.error(fallbackError);
-          throw error;
-        }
-      } else {
-        throw error;
-      }
-    }
-  }
-  getState() {
-    return this.state;
-  }
-  getMetrics() {
-    return {
-      ...this.metrics,
-      state: this.state,
-      nextAttemptTime: this.nextAttemptTime
-    };
-  }
-  forceOpen() {
-    this.transitionToOpen();
-  }
-  forceClosed() {
-    this.transitionToClosed();
-  }
-  reset() {
-    this.metrics = {
-      totalRequests: 0,
-      successfulRequests: 0,
-      failedRequests: 0,
-      timeouts: 0,
-      averageResponseTime: 0,
-      state: this.state,
-      consecutiveFailures: 0,
-      consecutiveSuccesses: 0
-    };
-    this.recentRequests = [];
-  }
-  onSuccess(responseTime) {
-    this.metrics.totalRequests++;
-    this.metrics.successfulRequests++;
-    this.metrics.consecutiveSuccesses++;
-    this.metrics.consecutiveFailures = 0;
-    this.metrics.lastSuccessTime = new Date;
-    this.updateAverageResponseTime(responseTime);
-    this.recentRequests.push({
-      timestamp: new Date,
-      success: true,
-      responseTime
-    });
-    if (this.state === "HALF_OPEN") {
-      if (this.metrics.consecutiveSuccesses >= this.config.halfOpenMaxCalls) {
-        this.transitionToClosed();
-      }
-    }
-    if (this.config.onSuccess) {
-      this.config.onSuccess(this.config.name);
-    }
-  }
-  onFailure(error, responseTime) {
-    this.metrics.totalRequests++;
-    this.metrics.failedRequests++;
-    this.metrics.consecutiveFailures++;
-    this.metrics.consecutiveSuccesses = 0;
-    this.metrics.lastFailureTime = new Date;
-    if (error instanceof TimeoutException) {
-      this.metrics.timeouts++;
-    }
-    this.updateAverageResponseTime(responseTime);
-    this.recentRequests.push({
-      timestamp: new Date,
-      success: false,
-      responseTime
-    });
-    if (this.shouldTrip(error)) {
-      if (this.state === "CLOSED") {
-        this.transitionToOpen();
-      } else if (this.state === "HALF_OPEN") {
-        this.transitionToOpen();
-      }
-    }
-    if (this.config.onFailure) {
-      this.config.onFailure(error, this.config.name);
-    }
-  }
-  shouldTrip(error) {
-    if (this.config.shouldTripOnError && !this.config.shouldTripOnError(error)) {
-      return false;
-    }
-    if (this.metrics.consecutiveFailures >= this.config.failureThreshold) {
-      return true;
-    }
-    const recentRequests = this.getRecentRequests();
-    if (recentRequests.length >= this.config.minimumRequests) {
-      const failedRequests = recentRequests.filter((r) => !r.success).length;
-      const errorRate = failedRequests / recentRequests.length * 100;
-      if (errorRate >= this.config.errorThresholdPercentage) {
-        return true;
-      }
-    }
-    return false;
-  }
-  transitionToClosed() {
-    this.state = "CLOSED";
-    this.nextAttemptTime = undefined;
-    this.halfOpenCallCount = 0;
-    this.metrics.state = this.state;
-    if (this.config.onStateChange) {
-      this.config.onStateChange(this.state, this.config.name);
-    }
-  }
-  transitionToOpen() {
-    this.state = "OPEN";
-    this.nextAttemptTime = new Date(Date.now() + this.config.recoveryTimeout);
-    this.halfOpenCallCount = 0;
-    this.metrics.state = this.state;
-    this.metrics.nextAttemptTime = this.nextAttemptTime;
-    if (this.config.onStateChange) {
-      this.config.onStateChange(this.state, this.config.name);
-    }
-  }
-  transitionToHalfOpen() {
-    this.state = "HALF_OPEN";
-    this.halfOpenCallCount = 0;
-    this.metrics.state = this.state;
-    if (this.config.onStateChange) {
-      this.config.onStateChange(this.state, this.config.name);
-    }
-  }
-  updateAverageResponseTime(responseTime) {
-    if (this.metrics.totalRequests === 1) {
-      this.metrics.averageResponseTime = responseTime;
-    } else {
-      const alpha = 0.1;
-      this.metrics.averageResponseTime = alpha * responseTime + (1 - alpha) * this.metrics.averageResponseTime;
-    }
-  }
-  getRecentRequests() {
-    const cutoff = new Date(Date.now() - this.config.monitoringPeriod);
-    return this.recentRequests.filter((r) => r.timestamp > cutoff);
-  }
-  cleanupOldRequests() {
-    const cutoff = new Date(Date.now() - this.config.monitoringPeriod);
-    this.recentRequests = this.recentRequests.filter((r) => r.timestamp > cutoff);
-  }
-}
-
-class CircuitBreakerRegistry {
-  breakers = new Map;
-  configs = new Map;
-  register(config2) {
-    const breaker = new CircuitBreaker(config2);
-    this.breakers.set(config2.name, breaker);
-    this.configs.set(config2.name, config2);
-    return breaker;
-  }
-  get(name) {
-    return this.breakers.get(name);
-  }
-  async execute(name, call) {
-    const breaker = this.breakers.get(name);
-    if (!breaker) {
-      throw new Error(`Circuit breaker '${name}' not found`);
-    }
-    return breaker.execute(call);
-  }
-  getAllMetrics() {
-    const metrics = {};
-    for (const [name, breaker] of this.breakers) {
-      metrics[name] = breaker.getMetrics();
-    }
-    return metrics;
-  }
-  getBreakersByState(state) {
-    const names = [];
-    for (const [name, breaker] of this.breakers) {
-      if (breaker.getState() === state) {
-        names.push(name);
-      }
-    }
-    return names;
-  }
-  forceAllClosed() {
-    for (const breaker of this.breakers.values()) {
-      breaker.forceClosed();
-    }
-  }
-  resetAll() {
-    for (const breaker of this.breakers.values()) {
-      breaker.reset();
-    }
-  }
-  remove(name) {
-    this.configs.delete(name);
-    return this.breakers.delete(name);
-  }
-  getNames() {
-    return Array.from(this.breakers.keys());
-  }
-}
-function circuitBreaker(config2) {
-  const breaker = new CircuitBreaker(config2);
-  return function(target, propertyName, descriptor) {
-    const method = descriptor.value;
-    descriptor.value = async function(...args) {
-      return breaker.execute({
-        execute: () => method.apply(this, args),
-        context: {
-          method: propertyName,
-          timestamp: new Date
-        }
-      });
-    };
-    return descriptor;
-  };
-}
-
-class CircuitBreakerHttpClient {
-  registry;
-  constructor(registry) {
-    this.registry = registry || new CircuitBreakerRegistry;
-  }
-  async fetch(url, options = {}) {
-    const { circuitBreaker: circuitBreaker2, fallback, context, ...fetchOptions } = options;
-    let breakerName;
-    if (typeof circuitBreaker2 === "string") {
-      breakerName = circuitBreaker2;
-    } else if (circuitBreaker2) {
-      breakerName = circuitBreaker2.name;
-      if (!this.registry.get(breakerName)) {
-        this.registry.register(circuitBreaker2);
-      }
-    } else {
-      const hostname = new URL(url).hostname;
-      breakerName = `http-${hostname}`;
-      if (!this.registry.get(breakerName)) {
-        this.registry.register({
-          name: breakerName,
-          failureThreshold: 5,
-          recoveryTimeout: 60000,
-          timeout: 30000,
-          monitoringPeriod: 60000,
-          minimumRequests: 10,
-          errorThresholdPercentage: 50,
-          halfOpenMaxCalls: 3,
-          resetTimeout: 60000
-        });
-      }
-    }
-    return this.registry.execute(breakerName, {
-      execute: async () => {
-        const response = await fetch(url, fetchOptions);
-        if (response.status >= 500) {
-          throw new ExternalServiceException(`HTTP ${response.status}: ${response.statusText}`, breakerName, url, response.status, undefined, context);
-        }
-        return response;
-      },
-      fallback,
-      context
-    });
-  }
-  getRegistry() {
-    return this.registry;
-  }
-}
-function createCircuitBreakerMiddleware(registry) {
-  return async (req, next) => {
-    const serviceName = req.context?.serviceName;
-    if (!serviceName) {
-      return next();
-    }
-    const breaker = registry.get(serviceName);
-    if (!breaker) {
-      return next();
-    }
-    return breaker.execute({
-      execute: next,
-      context: {
-        requestId: req.requestId,
-        route: req.route,
-        method: req.method,
-        url: req.url
-      }
-    });
-  };
-}
-var CircuitBreakerPresets = {
-  critical: (name) => ({
-    name,
-    failureThreshold: 3,
-    recoveryTimeout: 30000,
-    timeout: 5000,
-    monitoringPeriod: 30000,
-    minimumRequests: 5,
-    errorThresholdPercentage: 30,
-    halfOpenMaxCalls: 2,
-    resetTimeout: 30000
-  }),
-  standard: (name) => ({
-    name,
-    failureThreshold: 5,
-    recoveryTimeout: 60000,
-    timeout: 30000,
-    monitoringPeriod: 60000,
-    minimumRequests: 10,
-    errorThresholdPercentage: 50,
-    halfOpenMaxCalls: 3,
-    resetTimeout: 60000
-  }),
-  tolerant: (name) => ({
-    name,
-    failureThreshold: 10,
-    recoveryTimeout: 120000,
-    timeout: 60000,
-    monitoringPeriod: 120000,
-    minimumRequests: 20,
-    errorThresholdPercentage: 70,
-    halfOpenMaxCalls: 5,
-    resetTimeout: 120000
-  }),
-  database: (name) => ({
-    name,
-    failureThreshold: 3,
-    recoveryTimeout: 60000,
-    timeout: 1e4,
-    monitoringPeriod: 60000,
-    minimumRequests: 5,
-    errorThresholdPercentage: 40,
-    halfOpenMaxCalls: 2,
-    resetTimeout: 60000,
-    shouldTripOnError: (error) => {
-      return !(error.message.includes("validation") || error.message.includes("constraint"));
-    }
-  }),
-  externalApi: (name) => ({
-    name,
-    failureThreshold: 5,
-    recoveryTimeout: 90000,
-    timeout: 15000,
-    monitoringPeriod: 90000,
-    minimumRequests: 8,
-    errorThresholdPercentage: 60,
-    halfOpenMaxCalls: 3,
-    resetTimeout: 90000,
-    shouldTripOnError: (error) => {
-      if (error instanceof ExternalServiceException) {
-        return error.statusCode >= 500;
-      }
-      return true;
-    }
-  })
-};
-var globalCircuitBreakerRegistry = new CircuitBreakerRegistry;
-function createCircuitBreaker(config2) {
-  return globalCircuitBreakerRegistry.register(config2);
-}
-async function withCircuitBreaker(name, call) {
-  return globalCircuitBreakerRegistry.execute(name, call);
-}
-// src/errors/error-reporting.ts
-class SentryReporter {
-  config;
-  sentry;
-  constructor(config2) {
-    this.config = config2;
-    this.initializeSentry();
-  }
-  async initializeSentry() {
-    try {
-      const Sentry = await import("@sentry/node");
-      Sentry.init({
-        dsn: this.config.dsn,
-        environment: this.config.environment || "production",
-        release: this.config.release,
-        sampleRate: this.config.sampleRate || 1,
-        beforeSend: (event, hint) => {
-          const error = hint.originalException;
-          if (error && this.config.beforeSend) {
-            const filteredError = this.config.beforeSend(error, error.context);
-            return filteredError ? event : null;
-          }
-          return event;
-        },
-        ignoreErrors: this.config.filters?.ignoreErrors,
-        denyUrls: this.config.filters?.ignoreUrls,
-        allowUrls: this.config.filters?.allowUrls,
-        initialScope: {
-          tags: this.config.tags,
-          extra: this.config.extra,
-          user: this.config.user
-        },
-        maxBreadcrumbs: this.config.breadcrumbs?.maxBreadcrumbs || 100,
-        tracesSampleRate: this.config.performance?.tracesSampleRate || 0.1
-      });
-      this.sentry = Sentry;
-    } catch (error) {
-      console.warn("Failed to initialize Sentry:", error);
-    }
-  }
-  async report(error, context) {
-    if (!this.sentry || !this.config.enabled) {
-      return null;
-    }
-    try {
-      if (this.shouldIgnoreError(error)) {
-        return null;
-      }
-      const mergedContext = { ...error.context, ...context };
-      return this.sentry.withScope((scope) => {
-        if (mergedContext.requestId) {
-          scope.setTag("requestId", mergedContext.requestId);
-        }
-        if (mergedContext.userId) {
-          scope.setUser({ id: mergedContext.userId });
-        }
-        if (mergedContext.traceId) {
-          scope.setTag("traceId", mergedContext.traceId);
-        }
-        if (mergedContext.route) {
-          scope.setTag("route", mergedContext.route);
-        }
-        if (mergedContext.method) {
-          scope.setTag("method", mergedContext.method);
-        }
-        scope.setTag("errorCode", error.code);
-        scope.setTag("severity", error.severity);
-        scope.setTag("category", error.category);
-        scope.setLevel(this.mapSeverityToLevel(error.severity));
-        scope.setExtra("statusCode", error.statusCode);
-        scope.setExtra("retryable", error.retryable);
-        scope.setExtra("timestamp", error.timestamp);
-        scope.setExtra("context", mergedContext);
-        const fingerprint = this.generateFingerprint(error);
-        if (fingerprint.length > 0) {
-          scope.setFingerprint(fingerprint);
-        }
-        return this.sentry.captureException(error);
-      });
-    } catch (reportingError) {
-      console.error("Failed to report error to Sentry:", reportingError);
-      return null;
-    }
-  }
-  addBreadcrumb(message, category = "default", level = "info", data) {
-    if (!this.sentry || !this.config.breadcrumbs?.enabled) {
-      return;
-    }
-    this.sentry.addBreadcrumb({
-      message,
-      category,
-      level,
-      data,
-      timestamp: Date.now() / 1000
-    });
-  }
-  setUser(user) {
-    if (!this.sentry)
-      return;
-    this.sentry.setUser(user);
-  }
-  setTag(key, value) {
-    if (!this.sentry)
-      return;
-    this.sentry.setTag(key, value);
-  }
-  setExtra(key, value) {
-    if (!this.sentry)
-      return;
-    this.sentry.setExtra(key, value);
-  }
-  setContext(key, context) {
-    if (!this.sentry)
-      return;
-    this.sentry.setContext(key, context);
-  }
-  async close(timeout = 2000) {
-    if (!this.sentry)
-      return true;
-    return this.sentry.close(timeout);
-  }
-  shouldIgnoreError(error) {
-    const filters = this.config.filters;
-    if (!filters)
-      return false;
-    if (filters.ignoreCodes?.includes(error.code)) {
-      return true;
-    }
-    if (filters.ignoreErrors?.some((pattern) => {
-      if (typeof pattern === "string") {
-        return error.message.includes(pattern);
-      }
-      return pattern.test(error.message);
-    })) {
-      return true;
-    }
-    return false;
-  }
-  mapSeverityToLevel(severity) {
-    switch (severity) {
-      case "low":
-        return "info";
-      case "medium":
-        return "warning";
-      case "high":
-        return "error";
-      case "critical":
-        return "fatal";
-      default:
-        return "error";
-    }
-  }
-  generateFingerprint(error) {
-    const fingerprint = [];
-    fingerprint.push(error.code);
-    fingerprint.push(error.category);
-    if (error.context.route) {
-      fingerprint.push(error.context.route);
-    }
-    return fingerprint;
-  }
-}
-
-class BugsnagReporter {
-  config;
-  bugsnag;
-  constructor(config2) {
-    this.config = config2;
-    this.initializeBugsnag();
-  }
-  async initializeBugsnag() {
-    try {
-      const Bugsnag = await import("@bugsnag/js");
-      Bugsnag.start({
-        apiKey: this.config.apiKey,
-        appVersion: this.config.release,
-        releaseStage: this.config.environment || "production",
-        enabledReleaseStages: ["production", "staging"],
-        maxBreadcrumbs: this.config.breadcrumbs?.maxBreadcrumbs || 25,
-        onError: (event) => {
-          const error = event.originalError;
-          if (error && this.config.beforeSend) {
-            const filteredError = this.config.beforeSend(error, error.context);
-            return filteredError !== null;
-          }
-          return !this.shouldIgnoreError(error);
-        }
-      });
-      this.bugsnag = Bugsnag;
-    } catch (error) {
-      console.warn("Failed to initialize Bugsnag:", error);
-    }
-  }
-  async report(error, context) {
-    if (!this.bugsnag || !this.config.enabled) {
-      return null;
-    }
-    try {
-      if (this.shouldIgnoreError(error)) {
-        return null;
-      }
-      const mergedContext = { ...error.context, ...context };
-      this.bugsnag.notify(error, (event) => {
-        event.severity = this.mapSeverityToBugsnag(error.severity);
-        event.context = mergedContext.route || mergedContext.url;
-        if (mergedContext.userId) {
-          event.setUser(mergedContext.userId, undefined, undefined);
-        }
-        event.addMetadata("error", {
-          code: error.code,
-          category: error.category,
-          statusCode: error.statusCode,
-          retryable: error.retryable,
-          timestamp: error.timestamp
-        });
-        event.addMetadata("request", {
-          requestId: mergedContext.requestId,
-          method: mergedContext.method,
-          url: mergedContext.url,
-          userAgent: mergedContext.userAgent,
-          ip: mergedContext.ip
-        });
-        event.groupingHash = this.generateGroupingHash(error);
-      });
-      return "reported";
-    } catch (reportingError) {
-      console.error("Failed to report error to Bugsnag:", reportingError);
-      return null;
-    }
-  }
-  addBreadcrumb(message, category = "manual", _level = "info", data) {
-    if (!this.bugsnag || !this.config.breadcrumbs?.enabled) {
-      return;
-    }
-    this.bugsnag.leaveBreadcrumb(message, data, category);
-  }
-  setUser(user) {
-    if (!this.bugsnag)
-      return;
-    this.bugsnag.setUser(user.id, user.email, user.username);
-  }
-  setTag(key, value) {
-    if (!this.bugsnag)
-      return;
-    this.bugsnag.addMetadata("tags", { [key]: value });
-  }
-  setExtra(key, value) {
-    if (!this.bugsnag)
-      return;
-    this.bugsnag.addMetadata("extra", { [key]: value });
-  }
-  setContext(key, context) {
-    if (!this.bugsnag)
-      return;
-    this.bugsnag.addMetadata(key, context);
-  }
-  async close() {
-    return true;
-  }
-  shouldIgnoreError(error) {
-    const filters = this.config.filters;
-    if (!filters)
-      return false;
-    if (filters.ignoreCodes?.includes(error.code)) {
-      return true;
-    }
-    if (filters.ignoreErrors?.some((pattern) => {
-      if (typeof pattern === "string") {
-        return error.message.includes(pattern);
-      }
-      return pattern.test(error.message);
-    })) {
-      return true;
-    }
-    return false;
-  }
-  mapSeverityToBugsnag(severity) {
-    switch (severity) {
-      case "low":
-        return "info";
-      case "medium":
-        return "warning";
-      case "high":
-        return "error";
-      case "critical":
-        return "error";
-      default:
-        return "warning";
-    }
-  }
-  generateGroupingHash(error) {
-    return `${error.code}-${error.category}-${error.context.route || "unknown"}`;
-  }
-}
-
-class CustomReporter {
-  config;
-  reportHandler;
-  constructor(config2, reportHandler) {
-    this.config = config2;
-    this.reportHandler = reportHandler;
-  }
-  async report(error, context) {
-    if (!this.config.enabled) {
-      return null;
-    }
-    try {
-      const mergedContext = { ...error.context, ...context };
-      if (this.config.beforeSend) {
-        const filteredError = this.config.beforeSend(error, mergedContext);
-        if (!filteredError) {
-          return null;
-        }
-      }
-      const report = {
-        error,
-        context: mergedContext,
-        level: this.mapSeverityToLevel(error.severity),
-        tags: this.config.tags,
-        extra: this.config.extra,
-        user: this.config.user
-      };
-      return await this.reportHandler(report);
-    } catch (reportingError) {
-      console.error("Failed to report error with custom handler:", reportingError);
-      return null;
-    }
-  }
-  addBreadcrumb() {}
-  setUser() {}
-  setTag() {}
-  setExtra() {}
-  setContext() {}
-  async close() {
-    return true;
-  }
-  mapSeverityToLevel(severity) {
-    switch (severity) {
-      case "low":
-        return "info";
-      case "medium":
-        return "warning";
-      case "high":
-        return "error";
-      case "critical":
-        return "fatal";
-      default:
-        return "error";
-    }
-  }
-}
-
-class ErrorReportingManager {
-  reporters = [];
-  breadcrumbs = [];
-  maxBreadcrumbs = 50;
-  constructor(configs) {
-    this.initializeReporters(configs);
-  }
-  initializeReporters(configs) {
-    for (const config2 of configs) {
-      if (!config2.enabled)
-        continue;
-      switch (config2.service) {
-        case "sentry":
-          this.reporters.push(new SentryReporter(config2));
-          break;
-        case "bugsnag":
-          this.reporters.push(new BugsnagReporter(config2));
-          break;
-        case "custom":
-          break;
-      }
-    }
-  }
-  addReporter(reporter) {
-    this.reporters.push(reporter);
-  }
-  async report(error, context) {
-    const reportIds = [];
-    this.addBreadcrumb(`Error occurred: ${error.message}`, "error", {
-      code: error.code,
-      severity: error.severity
-    });
-    const promises = this.reporters.map(async (reporter) => {
-      try {
-        const reportId = await reporter.report(error, context);
-        if (reportId) {
-          reportIds.push(reportId);
-        }
-      } catch (reportingError) {
-        console.error("Reporter failed:", reportingError);
-      }
-    });
-    await Promise.allSettled(promises);
-    return reportIds;
-  }
-  addBreadcrumb(message, category = "default", data) {
-    this.breadcrumbs.push({
-      message,
-      timestamp: new Date,
-      data: { category, ...data }
-    });
-    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
-      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
-    }
-    this.reporters.forEach((reporter) => {
-      reporter.addBreadcrumb(message, category, "info", data);
-    });
-  }
-  setUser(user) {
-    this.reporters.forEach((reporter) => reporter.setUser(user));
-  }
-  setTag(key, value) {
-    this.reporters.forEach((reporter) => reporter.setTag(key, value));
-  }
-  setExtra(key, value) {
-    this.reporters.forEach((reporter) => reporter.setExtra(key, value));
-  }
-  setContext(key, context) {
-    this.reporters.forEach((reporter) => reporter.setContext(key, context));
-  }
-  async close(timeout = 5000) {
-    const promises = this.reporters.map((reporter) => reporter.close(timeout));
-    const results = await Promise.allSettled(promises);
-    return results.every((result) => result.status === "fulfilled" && result.value);
-  }
-  getBreadcrumbs() {
-    return [...this.breadcrumbs];
-  }
-}
-function createErrorReporting(configs) {
-  return new ErrorReportingManager(configs);
-}
-var ErrorReportingPresets = {
-  sentry: (dsn, environment = "production") => ({
-    enabled: true,
-    service: "sentry",
-    dsn,
-    environment,
-    sampleRate: 1,
-    breadcrumbs: {
-      enabled: true,
-      maxBreadcrumbs: 100
-    },
-    performance: {
-      enabled: true,
-      tracesSampleRate: 0.1
-    },
-    filters: {
-      ignoreErrors: [
-        "Non-Error promise rejection captured",
-        "ResizeObserver loop limit exceeded"
-      ],
-      ignoreCodes: ["VALIDATION_ERROR"]
-    }
-  }),
-  bugsnag: (apiKey, environment = "production") => ({
-    enabled: true,
-    service: "bugsnag",
-    apiKey,
-    environment,
-    breadcrumbs: {
-      enabled: true,
-      maxBreadcrumbs: 25
-    },
-    filters: {
-      ignoreCodes: ["VALIDATION_ERROR"]
-    }
-  }),
-  development: () => ({
-    enabled: false,
-    service: "custom",
-    environment: "development"
-  })
-};
-
-// src/errors/graceful-degradation.ts
-class ServiceHealthMonitor {
-  healthStatus = new Map;
-  healthCheckIntervals = new Map;
-  config;
-  constructor(config2) {
-    this.config = config2;
-    this.initializeHealthChecks();
-  }
-  initializeHealthChecks() {
-    for (const [serviceName, healthConfig] of Object.entries(this.config.healthChecks)) {
-      if (!healthConfig.enabled)
-        continue;
-      this.healthStatus.set(serviceName, {
-        name: serviceName,
-        status: "healthy",
-        lastCheck: new Date,
-        responseTime: 0,
-        errorRate: 0,
-        availability: 100,
-        consecutiveFailures: 0
-      });
-      const interval = setInterval(() => this.performHealthCheck(serviceName, healthConfig), healthConfig.interval);
-      interval.unref?.();
-      this.healthCheckIntervals.set(serviceName, interval);
-    }
-  }
-  async performHealthCheck(serviceName, config2) {
-    const startTime = Date.now();
-    let isHealthy = false;
-    try {
-      const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), config2.timeout);
-      const response = await fetch(config2.endpoint, {
-        signal: controller.signal,
-        headers: config2.headers,
-        method: "GET"
-      });
-      clearTimeout(timeoutId);
-      isHealthy = config2.expectedStatus.includes(response.status);
-      if (isHealthy && config2.expectedBody) {
-        const body = await response.text();
-        if (typeof config2.expectedBody === "string") {
-          isHealthy = body.includes(config2.expectedBody);
-        } else {
-          isHealthy = config2.expectedBody.test(body);
-        }
-      }
-    } catch (error) {
-      console.error(error);
-      isHealthy = false;
-    }
-    const responseTime = Date.now() - startTime;
-    this.updateHealthStatus(serviceName, isHealthy, responseTime);
-    if (isHealthy && config2.onHealthy) {
-      config2.onHealthy();
-    } else if (!isHealthy && config2.onUnhealthy) {
-      config2.onUnhealthy(new Error(`Health check failed for ${serviceName}`));
-    }
-  }
-  updateHealthStatus(serviceName, isHealthy, responseTime) {
-    const current = this.healthStatus.get(serviceName);
-    if (!current)
-      return;
-    const updated = {
-      ...current,
-      lastCheck: new Date,
-      responseTime,
-      consecutiveFailures: isHealthy ? 0 : current.consecutiveFailures + 1
-    };
-    if (updated.consecutiveFailures === 0) {
-      updated.status = "healthy";
-    } else if (updated.consecutiveFailures < 3) {
-      updated.status = "degraded";
-    } else {
-      updated.status = "unhealthy";
-    }
-    const healthyCount = isHealthy ? 1 : 0;
-    updated.availability = current.availability * 0.9 + healthyCount * 10;
-    this.healthStatus.set(serviceName, updated);
-  }
-  getServiceHealth(serviceName) {
-    return this.healthStatus.get(serviceName);
-  }
-  getAllServiceHealth() {
-    return Array.from(this.healthStatus.values());
-  }
-  isServiceHealthy(serviceName) {
-    const health = this.healthStatus.get(serviceName);
-    return health?.status === "healthy";
-  }
-  isServiceDegraded(serviceName) {
-    const health = this.healthStatus.get(serviceName);
-    return health?.status === "degraded";
-  }
-  stop() {
-    for (const interval of this.healthCheckIntervals.values()) {
-      clearInterval(interval);
-    }
-    this.healthCheckIntervals.clear();
-  }
-}
-
-class GracefulDegradationManager {
-  config;
-  healthMonitor;
-  cache = new Map;
-  metrics = new Map;
-  constructor(config2) {
-    this.config = config2;
-    this.healthMonitor = new ServiceHealthMonitor(config2);
-  }
-  async handleFailure(serviceName, error, request, originalHandler) {
-    if (!this.config.enabled) {
-      throw error;
-    }
-    const strategy = this.config.fallbackStrategies[serviceName];
-    if (!strategy) {
-      throw error;
-    }
-    const context = {
-      request,
-      serviceName,
-      error,
-      attemptCount: 1,
-      startTime: new Date
-    };
-    return this.executeFallbackStrategy(strategy, context, originalHandler);
-  }
-  async executeFallbackStrategy(strategy, context, originalHandler) {
-    if (context.attemptCount <= strategy.retries) {
-      try {
-        if (context.attemptCount > 1) {
-          const delay = this.calculateBackoffDelay(strategy.backoff, context.attemptCount);
-          await this.sleep(delay);
-        }
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("Timeout")), strategy.timeout);
-        });
-        const result = await Promise.race([originalHandler(), timeoutPromise]);
-        this.updateMetrics(context.serviceName, true, Date.now() - context.startTime.getTime());
-        return result;
-      } catch (retryError) {
-        console.error(retryError);
-        context.attemptCount++;
-        if (context.attemptCount <= strategy.retries) {
-          return this.executeFallbackStrategy(strategy, context, originalHandler);
-        }
-      }
-    }
-    this.updateMetrics(context.serviceName, false, Date.now() - context.startTime.getTime());
-    switch (strategy.type) {
-      case "cache":
-        return this.handleCacheFallback(strategy, context);
-      case "static":
-        return this.handleStaticFallback(strategy, context);
-      case "simplified":
-        return this.handleSimplifiedFallback(strategy, context);
-      case "redirect":
-        return this.handleRedirectFallback(strategy, context);
-      case "custom":
-        return this.handleCustomFallback(strategy, context);
-      default:
-        throw context.error;
-    }
-  }
-  async handleCacheFallback(strategy, context) {
-    if (!strategy.cacheConfig) {
-      throw context.error;
-    }
-    const cacheKey = this.generateCacheKey(strategy.cacheConfig.key, context);
-    const cached = this.cache.get(cacheKey);
-    if (cached && (cached.expires > new Date || strategy.cacheConfig.staleWhileRevalidate)) {
-      const headers = new Headers({
-        "Content-Type": "application/json",
-        "X-Cache": "HIT",
-        "X-Degraded": "true",
-        "X-Service-Status": this.healthMonitor.getServiceHealth(context.serviceName)?.status || "unknown"
-      });
-      if (strategy.cacheConfig.staleWhileRevalidate && cached.expires <= new Date) {
-        headers.set("X-Cache", "STALE");
-      }
-      return new Response(JSON.stringify(cached.data), {
-        status: 200,
-        headers
-      });
-    }
-    throw context.error;
-  }
-  async handleStaticFallback(strategy, context) {
-    if (!strategy.staticResponse) {
-      throw context.error;
-    }
-    const headers = new Headers(strategy.staticResponse.headers || {});
-    headers.set("X-Degraded", "true");
-    headers.set("X-Fallback-Type", "static");
-    headers.set("X-Service-Status", this.healthMonitor.getServiceHealth(context.serviceName)?.status || "unknown");
-    return new Response(typeof strategy.staticResponse.body === "string" ? strategy.staticResponse.body : JSON.stringify(strategy.staticResponse.body), {
-      status: strategy.staticResponse.status,
-      headers
-    });
-  }
-  async handleSimplifiedFallback(strategy, context) {
-    const simplifiedData = {
-      message: "Service temporarily unavailable. Showing simplified view.",
-      status: "degraded",
-      timestamp: new Date().toISOString(),
-      requestId: context.request.requestId
-    };
-    return new Response(JSON.stringify(simplifiedData), {
-      status: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "X-Degraded": "true",
-        "X-Fallback-Type": "simplified",
-        "X-Service-Status": this.healthMonitor.getServiceHealth(context.serviceName)?.status || "unknown"
-      }
-    });
-  }
-  async handleRedirectFallback(strategy, context) {
-    if (!strategy.redirectConfig) {
-      throw context.error;
-    }
-    return new Response(null, {
-      status: strategy.redirectConfig.permanent ? 301 : 302,
-      headers: {
-        Location: strategy.redirectConfig.url,
-        "X-Degraded": "true",
-        "X-Fallback-Type": "redirect"
-      }
-    });
-  }
-  async handleCustomFallback(strategy, context) {
-    if (!strategy.fallbackHandler) {
-      throw context.error;
-    }
-    try {
-      const response = await strategy.fallbackHandler(context.error, context.error.context);
-      response.headers.set("X-Degraded", "true");
-      response.headers.set("X-Fallback-Type", "custom");
-      response.headers.set("X-Service-Status", this.healthMonitor.getServiceHealth(context.serviceName)?.status || "unknown");
-      return response;
-    } catch (fallbackError) {
-      console.error(fallbackError);
-      throw context.error;
-    }
-  }
-  cacheResponse(serviceName, key, data, ttl) {
-    const strategy = this.config.fallbackStrategies[serviceName];
-    if (strategy?.type === "cache" && strategy.cacheConfig) {
-      const cacheKey = this.generateCacheKey(key, { serviceName });
-      this.cache.set(cacheKey, {
-        data,
-        expires: new Date(Date.now() + ttl * 1000)
-      });
-    }
-  }
-  getServiceMetrics(serviceName) {
-    const metrics = this.metrics.get(serviceName);
-    if (!metrics || metrics.requests === 0) {
-      return { errorRate: 0, avgResponseTime: 0, totalRequests: 0 };
-    }
-    return {
-      errorRate: metrics.errors / metrics.requests * 100,
-      avgResponseTime: metrics.totalTime / metrics.requests,
-      totalRequests: metrics.requests
-    };
-  }
-  getSystemHealth() {
-    const services = this.healthMonitor.getAllServiceHealth();
-    const unhealthyCount = services.filter((s) => s.status === "unhealthy").length;
-    const degradedCount = services.filter((s) => s.status === "degraded").length;
-    let status = "healthy";
-    if (unhealthyCount > 0) {
-      status = unhealthyCount > services.length / 2 ? "unhealthy" : "degraded";
-    } else if (degradedCount > 0) {
-      status = "degraded";
-    }
-    return { status, services };
-  }
-  calculateBackoffDelay(backoff, attempt) {
-    if (backoff.type === "fixed") {
-      return backoff.delay;
-    }
-    const delay = backoff.delay * 2 ** (attempt - 1);
-    return Math.min(delay, backoff.maxDelay || 30000);
-  }
-  generateCacheKey(template, context) {
-    return template.replace("{service}", context.serviceName).replace("{url}", context.request.url).replace("{method}", context.request.method).replace("{userId}", String(context.request.user?.id || "anonymous"));
-  }
-  updateMetrics(serviceName, success, responseTime) {
-    const current = this.metrics.get(serviceName) || { requests: 0, errors: 0, totalTime: 0 };
-    current.requests++;
-    current.totalTime += responseTime;
-    if (!success) {
-      current.errors++;
-    }
-    this.metrics.set(serviceName, current);
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  stop() {
-    this.healthMonitor.stop();
-  }
-}
-function createGracefulDegradationMiddleware(config2) {
-  const manager = new GracefulDegradationManager(config2);
-  return async (req, next) => {
-    try {
-      const response = await next();
-      const serviceName = req.context?.serviceName;
-      if (serviceName && response.ok) {
-        const strategy = config2.fallbackStrategies[serviceName];
-        if (strategy?.type === "cache" && strategy.cacheConfig) {
-          try {
-            const data = await response.clone().json();
-            manager.cacheResponse(serviceName, strategy.cacheConfig.key, data, strategy.cacheConfig.ttl);
-          } catch {}
-        }
-      }
-      return response;
-    } catch (error) {
-      const serviceName = req.context?.serviceName;
-      if (serviceName && error instanceof Error) {
-        const routerError = error;
-        try {
-          return await manager.handleFailure(serviceName, routerError, req, next);
-        } catch (fallbackError) {
-          console.error(fallbackError);
-          throw error;
-        }
-      }
-      throw error;
-    }
-  };
-}
-var DegradationStrategies = {
-  cacheFirst: (ttl = 3600, staleWhileRevalidate = true) => ({
-    type: "cache",
-    priority: 1,
-    timeout: 5000,
-    retries: 2,
-    backoff: { type: "exponential", delay: 1000, maxDelay: 5000 },
-    cacheConfig: {
-      key: "{service}:{url}:{method}",
-      ttl,
-      staleWhileRevalidate
-    }
-  }),
-  staticFallback: (body, status = 200) => ({
-    type: "static",
-    priority: 2,
-    timeout: 1000,
-    retries: 0,
-    backoff: { type: "fixed", delay: 0 },
-    staticResponse: {
-      status,
-      body,
-      headers: { "Content-Type": "application/json" }
-    }
-  }),
-  simplifiedView: () => ({
-    type: "simplified",
-    priority: 3,
-    timeout: 1000,
-    retries: 0,
-    backoff: { type: "fixed", delay: 0 }
-  }),
-  redirectToMaintenance: (url) => ({
-    type: "redirect",
-    priority: 4,
-    timeout: 1000,
-    retries: 0,
-    backoff: { type: "fixed", delay: 0 },
-    redirectConfig: {
-      url,
-      permanent: false
-    }
-  })
-};
-
-// src/errors/error-handler.ts
-class AdvancedErrorHandler {
-  errorReporting;
-  gracefulDegradation;
-  circuitBreakerRegistry;
-  config;
-  constructor(config2 = {}) {
-    this.config = {
-      development: false,
-      includeStackTrace: false,
-      sanitizeErrors: true,
-      logErrors: true,
-      ...config2
-    };
-    this.initializeComponents();
-  }
-  initializeComponents() {
-    if (this.config.errorReporting?.length) {
-      this.errorReporting = new ErrorReportingManager(this.config.errorReporting);
-    }
-    if (this.config.gracefulDegradation?.enabled) {
-      this.gracefulDegradation = new GracefulDegradationManager(this.config.gracefulDegradation);
-    }
-    if (this.config.circuitBreakers?.length) {
-      this.circuitBreakerRegistry = new CircuitBreakerRegistry;
-      for (const config2 of this.config.circuitBreakers) {
-        this.circuitBreakerRegistry.register(config2);
-      }
-    }
-  }
-  middleware() {
-    return async (req, next) => {
-      try {
-        const errorContext = {
-          requestId: req.requestId,
-          userId: req.user?.id,
-          traceId: req.traceId,
-          spanId: req.spanId,
-          route: req.params?.route || req.url,
-          method: req.method,
-          url: req.url,
-          userAgent: req.userAgent?.() || undefined,
-          ip: req.ip?.() || undefined,
-          timestamp: new Date
-        };
-        req.context = { ...req.context, errorContext };
-        if (this.circuitBreakerRegistry && req.context?.serviceName) {
-          const breaker = this.circuitBreakerRegistry.get(req.context.serviceName);
-          if (breaker) {
-            return await breaker.execute({
-              execute: next,
-              context: errorContext
-            });
-          }
-        }
-        return await next();
-      } catch (error) {
-        return this.handleError(error, req);
-      }
-    };
-  }
-  async handleError(error, req) {
-    const routerError = this.normalizeError(error, req);
-    if (this.errorReporting) {
-      this.errorReporting.addBreadcrumb(`Error in ${req.method} ${req.url}`, "error", {
-        code: routerError.code,
-        severity: routerError.severity,
-        statusCode: routerError.statusCode
-      });
-    }
-    if (this.config.logErrors) {
-      this.logError(routerError, req);
-    }
-    if (this.gracefulDegradation && req.context?.serviceName) {
-      try {
-        return await this.gracefulDegradation.handleFailure(req.context.serviceName, routerError, req, async () => {
-          throw routerError;
-        });
-      } catch {}
-    }
-    if (this.errorReporting) {
-      try {
-        await this.errorReporting.report(routerError, routerError.context);
-      } catch (reportingError) {
-        console.error("Failed to report error:", reportingError);
-      }
-    }
-    if (this.config.globalErrorHandler) {
-      try {
-        return await this.config.globalErrorHandler(routerError, req);
-      } catch (handlerError) {
-        console.error("Global error handler failed:", handlerError);
-      }
-    }
-    const customPage = this.config.customErrorPages?.[routerError.statusCode];
-    if (customPage) {
-      try {
-        if (typeof customPage === "string") {
-          return new Response(customPage, {
-            status: routerError.statusCode,
-            headers: { "Content-Type": "text/html" }
-          });
-        } else {
-          return await customPage(routerError, req);
-        }
-      } catch (pageError) {
-        console.error("Custom error page failed:", pageError);
-      }
-    }
-    return this.createErrorResponse(routerError, req);
-  }
-  normalizeError(error, req) {
-    const errorContext = {
-      requestId: req.requestId,
-      userId: req.user?.id,
-      traceId: req.traceId,
-      spanId: req.spanId,
-      route: req.params?.route || req.url,
-      method: req.method,
-      url: req.url,
-      userAgent: req.userAgent?.() || undefined,
-      ip: req.ip?.() || undefined,
-      timestamp: new Date,
-      metadata: req.context
+      keyName: "X-API-Key",
+      keyPrefix: "bun_",
+      ...options
     };
-    if (error instanceof RouterException) {
-      return error;
-    }
-    if (error instanceof Error) {
-      if (error.name === "ValidationError") {
-        return ErrorFactory.validation(error.message, {}, errorContext);
-      }
-      if (error.name === "UnauthorizedError" || error.message.includes("unauthorized")) {
-        return ErrorFactory.authentication(error.message, errorContext);
-      }
-      if (error.name === "ForbiddenError" || error.message.includes("forbidden")) {
-        return ErrorFactory.authorization(error.message, [], errorContext);
-      }
-      if (error.name === "NotFoundError" || error.message.includes("not found")) {
-        return ErrorFactory.notFound(undefined, undefined, errorContext);
-      }
-      if (error.name === "TimeoutError" || error.message.includes("timeout")) {
-        return ErrorFactory.timeout(30000, error.message, errorContext);
-      }
-      return ErrorFactory.internalServer(error.message, error, errorContext);
-    }
-    if (typeof error === "string") {
-      return ErrorFactory.internalServer(error, undefined, errorContext);
-    }
-    return ErrorFactory.internalServer("An unknown error occurred", undefined, errorContext);
   }
-  createErrorResponse(error, _req) {
-    const isDevelopment = this.config.development;
-    const includeStackTrace = this.config.includeStackTrace || isDevelopment;
-    const sanitizeErrors = this.config.sanitizeErrors && !isDevelopment;
-    let message = error.message;
-    if (sanitizeErrors && error.statusCode >= 500) {
-      message = "An internal server error occurred";
-    }
-    const errorResponse = {
-      error: {
-        code: error.code,
-        message,
-        statusCode: error.statusCode,
-        timestamp: error.timestamp.toISOString(),
-        requestId: error.context.requestId,
-        traceId: error.context.traceId
-      }
-    };
-    if (isDevelopment) {
-      errorResponse.error.category = error.category;
-      errorResponse.error.severity = error.severity;
-      errorResponse.error.retryable = error.retryable;
-      errorResponse.error.context = error.context;
-    }
-    if (includeStackTrace) {
-      errorResponse.error.stack = error.stack;
-      if (error.cause) {
-        errorResponse.error.cause = {
-          name: error.cause.name,
-          message: error.cause.message,
-          stack: error.cause.stack
-        };
-      }
-    }
-    if ("fields" in error) {
-      errorResponse.error.fields = error.fields;
-    }
-    if ("allowedMethods" in error) {
-      errorResponse.error.allowedMethods = error.allowedMethods;
-    }
-    if ("retryAfter" in error) {
-      errorResponse.error.retryAfter = error.retryAfter;
-    }
-    const headers = new Headers({
-      "Content-Type": "application/json",
-      "X-Error-Code": error.code,
-      "X-Request-ID": error.context.requestId || "",
-      "X-Trace-ID": error.context.traceId || ""
+  generateKey(owner, scopes = [], expiresIn) {
+    const key = `${this.options.keyPrefix}${this.randomString(32)}`;
+    this.keys.set(key, {
+      owner,
+      scopes,
+      expiresAt: expiresIn ? new Date(Date.now() + expiresIn * 1000) : undefined
     });
-    if ("allowedMethods" in error) {
-      headers.set("Allow", error.allowedMethods.join(", "));
+    return key;
+  }
+  validateKey(key, requiredScopes = []) {
+    const keyInfo = this.keys.get(key);
+    if (!keyInfo) {
+      return false;
     }
-    if ("retryAfter" in error) {
-      headers.set("Retry-After", error.retryAfter.toString());
+    if (keyInfo.expiresAt && keyInfo.expiresAt < new Date) {
+      return false;
     }
-    if ("limit" in error) {
-      headers.set("X-RateLimit-Limit", error.limit.toString());
-      headers.set("X-RateLimit-Remaining", error.remaining.toString());
+    if (requiredScopes.length > 0) {
+      return requiredScopes.every((scope) => keyInfo.scopes.includes(scope));
     }
-    return new Response(JSON.stringify(errorResponse), {
-      status: error.statusCode,
-      headers
-    });
+    return true;
   }
-  logError(error, req) {
-    const logData = {
-      error: error.toJSON(),
-      request: {
-        method: req.method,
-        url: req.url,
-        headers: Object.fromEntries(req.headers.entries()),
-        userAgent: req.userAgent?.() || undefined,
-        ip: req.ip?.() || undefined,
-        requestId: req.requestId,
-        traceId: req.traceId
-      }
-    };
-    switch (error.severity) {
-      case "critical":
-        console.error("[CRITICAL ERROR]", logData);
-        break;
-      case "high":
-        console.error("[ERROR]", logData);
-        break;
-      case "medium":
-        console.warn("[WARNING]", logData);
-        break;
-      case "low":
-        console.warn("[INFO]", logData);
-        break;
-      default:
-        console.error("[ERROR]", logData);
-    }
+  getKeyInfo(key) {
+    return this.keys.get(key) || null;
   }
-  getStats() {
-    return {
-      errorReporting: this.errorReporting ? {
-        breadcrumbs: this.errorReporting.getBreadcrumbs().length
-      } : undefined,
-      gracefulDegradation: this.gracefulDegradation ? this.gracefulDegradation.getSystemHealth() : undefined,
-      circuitBreakers: this.circuitBreakerRegistry ? this.circuitBreakerRegistry.getAllMetrics() : undefined
-    };
+  revokeKey(key) {
+    return this.keys.delete(key);
   }
-  async cleanup() {
-    if (this.errorReporting) {
-      await this.errorReporting.close();
-    }
-    if (this.gracefulDegradation) {
-      this.gracefulDegradation.stop();
+  extractFromRequest(req) {
+    const { source, keyName } = this.options;
+    switch (source) {
+      case "header":
+        return req.headers.get(keyName || "X-API-Key") || null;
+      case "query":
+        return new URL(req.url).searchParams.get(keyName || "api_key") || null;
+      case "cookie":
+        if (req.cookies) {
+          const key = keyName || "api_key";
+          if (typeof req.cookies.get === "function") {
+            return req.cookies.get(key) || null;
+          }
+          return req.cookies[key] || null;
+        }
+        return null;
+      default:
+        return null;
     }
   }
-}
-function createAdvancedErrorHandler(config2 = {}) {
-  const handler = new AdvancedErrorHandler(config2);
-  return {
-    middleware: handler.middleware(),
-    getStats: () => handler.getStats(),
-    cleanup: () => handler.cleanup()
-  };
-}
-// src/request/context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var storage = new AsyncLocalStorage;
-var contextEnabled = false;
-var syncCurrent = null;
-function enableRequestContext() {
-  contextEnabled = true;
-}
-function runWithRequest(initial, fn) {
-  if (!contextEnabled) {
-    syncCurrent = initial;
-    const result = fn();
-    if (result instanceof Promise) {
-      return result.finally(() => {
-        syncCurrent = null;
-      });
+  randomString(length) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0;i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
     }
-    syncCurrent = null;
     return result;
   }
-  return storage.run({ current: initial }, fn);
 }
-function setCurrentRequest(req) {
-  const store = storage.getStore();
-  if (store) {
-    store.current = req;
-    return;
+
+class OAuth2Helper {
+  config;
+  constructor(config2) {
+    this.config = config2;
   }
-  if (syncCurrent !== null) {
-    syncCurrent = req;
+  getAuthorizationUrl(additionalParams = {}) {
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      redirect_uri: this.config.redirectUri,
+      response_type: "code",
+      ...additionalParams
+    });
+    if (this.config.scope) {
+      params.set("scope", this.config.scope);
+    }
+    if (this.config.state) {
+      params.set("state", this.config.state);
+    }
+    return `${this.config.authorizeUrl}?${params.toString()}`;
   }
-}
-function getCurrentRequest() {
-  if (!contextEnabled) {
-    contextEnabled = true;
-    return syncCurrent ?? undefined;
+  async exchangeCodeForToken(code) {
+    const params = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: this.config.redirectUri,
+      client_id: this.config.clientId,
+      client_secret: this.config.clientSecret
+    });
+    const response = await fetch(this.config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      throw new Error(`OAuth token exchange failed: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
   }
-  return storage.getStore()?.current ?? syncCurrent ?? undefined;
-}
-function request() {
-  const req = getCurrentRequest();
-  if (!req) {
-    throw new Error("request() called outside a request scope. It can only be invoked from within a route handler or middleware.");
+  async refreshToken(refreshToken) {
+    const params = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.config.clientId,
+      client_secret: this.config.clientSecret
+    });
+    const response = await fetch(this.config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      throw new Error(`OAuth token refresh failed: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
   }
-  return req;
 }
 // src/response/response-factory.ts
 var response = {
@@ -2143,8 +429,8 @@ var response = {
   redirectTemporary: (url) => {
     return response.redirect(url, 302);
   },
-  back: (request2, fallback = "/") => {
-    const referer = request2.headers.get("referer") || fallback;
+  back: (request, fallback = "/") => {
+    const referer = request.headers.get("referer") || fallback;
     return response.redirect(referer);
   },
   view: (html, status = 200, headers = {}) => {
@@ -2389,7 +675,7 @@ class MiddlewarePipeline {
     }
     this.compiledPipelines.set(routeKey, compiled);
   }
-  async execute(routeKey, request2, finalHandler) {
+  async execute(routeKey, request, finalHandler) {
     const startTime = performance.now();
     this.stats.totalExecutions++;
     const pipeline = this.compiledPipelines.get(routeKey);
@@ -2399,7 +685,7 @@ class MiddlewarePipeline {
     }
     this.stats.cacheHits++;
     const context = {
-      request: request2,
+      request,
       dependencies: new Map,
       metadata: {}
     };
@@ -2414,7 +700,7 @@ class MiddlewarePipeline {
         this.stats.skippedMiddleware++;
         return await next();
       }
-      const result2 = await middleware2.handler(request2, next);
+      const result2 = await middleware2.handler(request, next);
       if (result2 instanceof Response && middleware2.canShortCircuit) {
         this.stats.shortCircuits++;
         return result2;
@@ -3492,12 +1778,12 @@ class StreamHandler {
   }
 }
 class FileStreamHandler {
-  static async streamFile(filePath, request2, options = {}) {
+  static async streamFile(filePath, request, options = {}) {
     const { contentType, enableRanges = true, chunkSize: _chunkSize = 64 * 1024 } = options;
     try {
       const file = Bun.file(filePath);
       const fileSize = file.size;
-      const range = enableRanges ? request2.headers.get("range") : null;
+      const range = enableRanges ? request.headers.get("range") : null;
       if (range && enableRanges) {
         return FileStreamHandler.handleRangeRequest(file, range, contentType);
       }
@@ -3576,8 +1862,8 @@ function closeReadableStreamAfterError(controller, error) {
 function registerFileStreaming(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     streamFile: {
-      value(filePath, request2, options) {
-        return FileStreamHandler.streamFile(filePath, request2, options);
+      value(filePath, request, options) {
+        return FileStreamHandler.streamFile(filePath, request, options);
       },
       writable: true,
       configurable: true
@@ -4932,7 +3218,6 @@ var SubdomainPatterns = {
 };
 
 // src/url.ts
-import process3 from "process";
 var namedRouteRegistry = new Map;
 function registerNamedRoute(name, path) {
   namedRouteRegistry.set(name, path);
@@ -4940,54 +3225,6 @@ function registerNamedRoute(name, path) {
 function getNamedRoutePath(name) {
   return namedRouteRegistry.get(name);
 }
-function getNamedRoutes() {
-  return new Map(namedRouteRegistry);
-}
-function clearNamedRoutes() {
-  namedRouteRegistry.clear();
-}
-function url(name, params = {}, options = {}) {
-  const path = namedRouteRegistry.get(name);
-  if (!path) {
-    const known = [...namedRouteRegistry.keys()].sort().join(", ") || "(none registered)";
-    throw new Error(`Named route '${name}' is not defined. Known routes: ${known}`);
-  }
-  const consumed = new Set;
-  let resolved = path;
-  for (const [key, value] of Object.entries(params)) {
-    const required = `{${key}}`;
-    const optional = `{${key}?}`;
-    const encoded = encodeURIComponent(String(value));
-    if (resolved.includes(required)) {
-      resolved = resolved.replaceAll(required, encoded);
-      consumed.add(key);
-    } else if (resolved.includes(optional)) {
-      resolved = resolved.replaceAll(optional, encoded);
-      consumed.add(key);
-    }
-  }
-  if (resolved.includes("?}")) {
-    resolved = resolved.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
-    if (resolved.length > 1 && resolved.endsWith("/"))
-      resolved = resolved.slice(0, -1);
-  }
-  const missing = resolved.match(/\{([^}?]+)\}/g);
-  if (missing && missing.length > 0)
-    throw new Error(`Missing required params for route '${name}': ${missing.join(", ")}`);
-  const leftover = Object.entries(params).filter(([k]) => !consumed.has(k));
-  if (leftover.length > 0) {
-    const qs = new URLSearchParams;
-    for (const [k, v] of leftover)
-      qs.set(k, String(v));
-    resolved += `?${qs.toString()}`;
-  }
-  if (options.absolute) {
-    const base = (options.base ?? process3.env.APP_URL ?? "http://localhost").replace(/\/$/, "");
-    const prefixed = base.startsWith("http") ? base : `https://${base}`;
-    return `${prefixed}${resolved.startsWith("/") ? resolved : `/${resolved}`}`;
-  }
-  return resolved;
-}
 
 // src/utils.ts
 import { join as join3 } from "path";
@@ -5541,24 +3778,24 @@ class FluentRouter {
   getRoutes() {
     return [...this.routes, ...this.subdomainRouter.getAllRoutes()];
   }
-  async handle(request2) {
-    const url2 = new URL(request2.url);
-    const domain = url2.hostname;
+  async handle(request) {
+    const url = new URL(request.url);
+    const domain = url.hostname;
     const match = this.subdomainRouter.findDomainGroup(domain);
     if (match) {
-      const enhancedReq = request2;
+      const enhancedReq = request;
       enhancedReq.domainParams = match.parameters;
       for (const route of match.group.getRoutes()) {
-        const params = this.matchRouteParams(route, request2.method, url2.pathname);
+        const params = this.matchRouteParams(route, request.method, url.pathname);
         if (params) {
           return await this.executeRoute(route, enhancedReq, params);
         }
       }
     }
     for (const route of this.routes) {
-      const params = this.matchRouteParams(route, request2.method, url2.pathname);
+      const params = this.matchRouteParams(route, request.method, url.pathname);
       if (params) {
-        return await this.executeRoute(route, request2, params);
+        return await this.executeRoute(route, request, params);
       }
     }
     return null;
@@ -5570,11 +3807,11 @@ class FluentRouter {
     const params = {};
     return matchPath(route.path, pathname, params) ? params : null;
   }
-  async executeRoute(route, request2, params) {
-    request2.params = params;
+  async executeRoute(route, request, params) {
+    request.params = params;
     const allMiddleware = [...this.globalMiddleware];
     for (const conditional of this.conditionalMiddleware) {
-      if (await conditional.condition(request2)) {
+      if (await conditional.condition(request)) {
         allMiddleware.push(...conditional.middleware);
       }
     }
@@ -5583,10 +3820,10 @@ class FluentRouter {
     const next = async () => {
       if (index < allMiddleware.length) {
         const middleware2 = allMiddleware[index++];
-        const result = await middleware2(request2, next);
+        const result = await middleware2(request, next);
         return result ?? new Response(null);
       }
-      return await route.handler(request2);
+      return await route.handler(request);
     };
     return await next();
   }
@@ -5624,27 +3861,27 @@ var RouteFactory = {
 };
 var RouterUtils = {
   route: (name, params = {}, query = {}) => {
-    let url2 = getNamedRoutePath(name) ?? `/${name}`;
+    let url = getNamedRoutePath(name) ?? `/${name}`;
     for (const [key, value] of Object.entries(params)) {
       const encoded = encodeURIComponent(value);
-      url2 = url2.replace(`{${key}}`, encoded);
-      url2 = url2.replace(`{${key}?}`, encoded);
+      url = url.replace(`{${key}}`, encoded);
+      url = url.replace(`{${key}?}`, encoded);
     }
-    if (url2.includes("?}")) {
-      url2 = url2.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
-      if (url2.length > 1 && url2.endsWith("/"))
-        url2 = url2.slice(0, -1);
+    if (url.includes("?}")) {
+      url = url.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
+      if (url.length > 1 && url.endsWith("/"))
+        url = url.slice(0, -1);
     }
     const queryString = new URLSearchParams(query).toString();
     if (queryString) {
-      url2 += `?${queryString}`;
+      url += `?${queryString}`;
     }
-    return url2;
+    return url;
   },
-  redirect: (url2, status = 302) => {
+  redirect: (url, status = 302) => {
     return new Response(null, {
       status,
-      headers: { Location: url2 }
+      headers: { Location: url }
     });
   },
   json: (data, status = 200) => {
@@ -5842,10 +4079,10 @@ function registerHttpMethods(RouterClass) {
           route.constraints = constraints;
         }
         route.pattern = {
-          exec: (url2) => {
+          exec: (url) => {
             const params = {};
             const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-            const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
+            const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
             if (!isMatch) {
               return null;
             }
@@ -5972,18 +4209,18 @@ function registerHttpMethods(RouterClass) {
         if (!route) {
           throw new Error(`Route with name "${name}" not found`);
         }
-        let url2 = route.path;
+        let url = route.path;
         for (const [param, value] of Object.entries(params)) {
-          url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
-          url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
+          url = url.replace(`{${param}}`, encodeURIComponent(value));
+          url = url.replace(`{${param}?}`, encodeURIComponent(value));
         }
-        if (url2.includes("{")) {
-          url2 = url2.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
-          if (url2.length > 1 && url2.endsWith("/")) {
-            url2 = url2.slice(0, -1);
+        if (url.includes("{")) {
+          url = url.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
+          if (url.length > 1 && url.endsWith("/")) {
+            url = url.slice(0, -1);
           }
         }
-        return url2;
+        return url;
       },
       writable: true,
       configurable: true
@@ -6001,9 +4238,9 @@ function registerHttpMethods(RouterClass) {
 function registerRedirectMethods(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     redirect: {
-      value(url2, status = 302) {
+      value(url, status = 302) {
         const headers = new Headers;
-        headers.set("Location", url2);
+        headers.set("Location", url);
         return new Response(null, {
           status,
           headers
@@ -6013,8 +4250,8 @@ function registerRedirectMethods(RouterClass) {
       configurable: true
     },
     permanentRedirect: {
-      value(url2) {
-        return this.redirect(url2, 301);
+      value(url) {
+        return this.redirect(url, 301);
       },
       writable: true,
       configurable: true
@@ -7012,8 +5249,8 @@ class RouteCompiler {
       }
       const pattern = this.convertToURLPattern(route.path, route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined);
       const urlPatternAdapter = {
-        exec: (url2) => {
-          const pathname = url2.pathname;
+        exec: (url) => {
+          const pathname = url.pathname;
           const result = pattern.exec(pathname);
           if (!result)
             return null;
@@ -7384,8 +5621,8 @@ function registerOptimizedRouteMatching(RouterClass) {
     },
     fallbackMatchRoute: {
       value(path, method, domain) {
-        const url2 = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
+        const url = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
@@ -7393,7 +5630,7 @@ function registerOptimizedRouteMatching(RouterClass) {
           this.routeCache.clear();
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -7406,7 +5643,7 @@ function registerOptimizedRouteMatching(RouterClass) {
         const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
         const methodRoutes = potentialRoutes.filter((route) => route.method === method);
         for (const route of methodRoutes) {
-          if (route.path === url2.pathname) {
+          if (route.path === url.pathname) {
             const result = {
               route,
               params: {}
@@ -7417,7 +5654,7 @@ function registerOptimizedRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url2);
+            const match = route.pattern.exec(url);
             if (match) {
               const result = {
                 route,
@@ -7435,10 +5672,10 @@ function registerOptimizedRouteMatching(RouterClass) {
               continue;
             }
             const basePath = route.path.slice(0, -1);
-            if (url2.pathname.startsWith(basePath)) {
+            if (url.pathname.startsWith(basePath)) {
               const result = {
                 route,
-                params: { wildcard: url2.pathname.slice(basePath.length) }
+                params: { wildcard: url.pathname.slice(basePath.length) }
               };
               this.routeCache.set(cacheKey, result);
               return result;
@@ -7560,10 +5797,10 @@ function registerRouteBuilding(RouterClass) {
               } catch {}
             }
             bunRoutes[path] = async (req) => {
-              const url2 = new URL(req.url);
+              const url = new URL(req.url);
               const params = {};
               const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-              matchPath(path, url2.pathname, params, constraintsRecord);
+              matchPath(path, url.pathname, params, constraintsRecord);
               const enhancedReq = this.enhanceRequest(req, params);
               const routeHandlerMiddleware = async (req2, _next) => await this.resolveHandler(route.handler, req2);
               const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware];
@@ -7575,10 +5812,10 @@ function registerRouteBuilding(RouterClass) {
             for (const route of routes) {
               const method = route.method;
               methodHandlers[method] = async (req) => {
-                const url2 = new URL(req.url);
+                const url = new URL(req.url);
                 const params = {};
                 const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-                matchPath(path, url2.pathname, params, constraintsRecord);
+                matchPath(path, url.pathname, params, constraintsRecord);
                 const enhancedReq = this.enhanceRequest(req, params);
                 const routeHandlerMiddleware = async (req2, _next) => await this.resolveHandler(route.handler, req2);
                 const middlewareStack = [...this.globalMiddleware, ...route.middleware, routeHandlerMiddleware];
@@ -7672,13 +5909,13 @@ function registerRouteMatching(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     matchRoute: {
       value(path, method, domain) {
-        const url2 = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
+        const url = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -7691,7 +5928,7 @@ function registerRouteMatching(RouterClass) {
         const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
         const methodRoutes = potentialRoutes.filter((route) => route.method === method);
         for (const route of methodRoutes) {
-          if (route.path === url2.pathname) {
+          if (route.path === url.pathname) {
             const result = {
               route,
               params: {}
@@ -7702,7 +5939,7 @@ function registerRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url2);
+            const match = route.pattern.exec(url);
             if (match) {
               const result = {
                 route,
@@ -7717,11 +5954,11 @@ function registerRouteMatching(RouterClass) {
           const wildcardRoutes = this.domains[domain].filter((route) => route.method === method && route.path.endsWith("*"));
           for (const route of wildcardRoutes) {
             const basePath = route.path.slice(0, -1);
-            if (url2.pathname.startsWith(basePath)) {
+            if (url.pathname.startsWith(basePath)) {
               const result = {
                 route,
                 params: {
-                  wildcard: url2.pathname.slice(basePath.length)
+                  wildcard: url.pathname.slice(basePath.length)
                 }
               };
               this.routeCache.set(cacheKey, result);
@@ -7732,11 +5969,11 @@ function registerRouteMatching(RouterClass) {
         const globalWildcardRoutes = this.routes.filter((route) => route.method === method && route.path.endsWith("*") && (!domain || !route.domain));
         for (const route of globalWildcardRoutes) {
           const basePath = route.path.slice(0, -1);
-          if (url2.pathname.startsWith(basePath)) {
+          if (url.pathname.startsWith(basePath)) {
             const result = {
               route,
               params: {
-                wildcard: url2.pathname.slice(basePath.length)
+                wildcard: url.pathname.slice(basePath.length)
               }
             };
             this.routeCache.set(cacheKey, result);
@@ -7837,9 +6074,9 @@ function registerRouteMatching(RouterClass) {
           const routePath = lastRoute.path;
           const constraintsRecord = lastRoute.constraints && !Array.isArray(lastRoute.constraints) ? lastRoute.constraints : undefined;
           lastRoute.pattern = {
-            exec: (url2) => {
+            exec: (url) => {
               const params2 = {};
-              const isMatch = matchPath(routePath, url2.pathname, params2, constraintsRecord);
+              const isMatch = matchPath(routePath, url.pathname, params2, constraintsRecord);
               if (!isMatch) {
                 return null;
               }
@@ -8090,10 +6327,10 @@ class Router {
       route.constraints = constraints;
     }
     route.pattern = {
-      exec: (url2) => {
+      exec: (url) => {
         const params = {};
         const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-        const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
+        const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
         if (!isMatch) {
           return null;
         }
@@ -8174,27 +6411,27 @@ class Router {
     if (!route) {
       throw new Error(`Route with name "${name}" not found`);
     }
-    let url2 = route.path;
+    let url = route.path;
     for (const [param, value] of Object.entries(params)) {
-      url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
-      url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
+      url = url.replace(`{${param}}`, encodeURIComponent(value));
+      url = url.replace(`{${param}?}`, encodeURIComponent(value));
     }
-    return url2;
+    return url;
   }
   onError(handler) {
     this.errorHandler = handler;
     return this;
   }
-  redirect(url2, status = 302) {
+  redirect(url, status = 302) {
     const headers = new Headers;
-    headers.set("Location", url2);
+    headers.set("Location", url);
     return new Response(null, {
       status,
       headers
     });
   }
-  permanentRedirect(url2) {
-    return this.redirect(url2, 301);
+  permanentRedirect(url) {
+    return this.redirect(url, 301);
   }
   redirectRoute(from, to, status = 302) {
     this.get(from, (_req) => {
@@ -8221,13 +6458,13 @@ class Router {
   }
   async handleRequest(req) {
     try {
-      const url2 = new URL(req.url);
+      const url = new URL(req.url);
       if (this.config.verbose) {
-        console.log(`${req.method} ${url2.pathname}`);
+        console.log(`${req.method} ${url.pathname}`);
       }
       if (req.method === "OPTIONS") {
-        const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-        const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
+        const hostname2 = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+        const optionsMatch = this.matchRoute(url.pathname, "OPTIONS", hostname2);
         if (!optionsMatch) {
           return new Response(null, {
             status: 204,
@@ -8240,8 +6477,8 @@ class Router {
           });
         }
       }
-      const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-      const match = this.matchRoute(url2.pathname, req.method, hostname);
+      const hostname = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+      const match = this.matchRoute(url.pathname, req.method, hostname);
       const enhancedReq = this.enhanceRequest(req, match?.params || {});
       if (match) {
         enhancedReq.route = match.route;
@@ -8259,12 +6496,12 @@ class Router {
         }
         return new Response("No response from middleware chain", { status: 500 });
       }
-      const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
+      const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
       if (allowedMethods.length > 0) {
         const methodNotAllowedHandler = async (_req, _next) => {
           return new Response(JSON.stringify({
             error: "Method Not Allowed",
-            path: url2.pathname,
+            path: url.pathname,
             method: req.method,
             allowed: allowedMethods
           }), {
@@ -8291,7 +6528,7 @@ class Router {
           }
           return new Response(JSON.stringify({
             error: "Not Found",
-            path: url2.pathname,
+            path: url.pathname,
             method: req.method
           }), {
             status: 404,
@@ -8310,7 +6547,7 @@ class Router {
       }
       return new Response(JSON.stringify({
         error: "Not Found",
-        path: url2.pathname,
+        path: url.pathname,
         method: req.method
       }), {
         status: 404,
@@ -8353,15 +6590,15 @@ class Router {
     }
   }
   getAllowedMethods(path, domain) {
-    const url2 = new URL(path, "http://localhost");
-    const cacheKey = `${domain || ""}:${url2.pathname}`;
+    const url = new URL(path, "http://localhost");
+    const cacheKey = `${domain || ""}:${url.pathname}`;
     const cached = this._allowedMethodsCache.get(cacheKey);
     if (cached) {
       return cached;
     }
     const methods = new Set;
     for (const [method, routesByPath] of this.staticRoutes) {
-      const staticRoute = routesByPath.get(url2.pathname);
+      const staticRoute = routesByPath.get(url.pathname);
       if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
         methods.add(method);
       }
@@ -8371,15 +6608,15 @@ class Router {
       if (methods.has(route.method)) {
         continue;
       }
-      if (route.path === url2.pathname) {
+      if (route.path === url.pathname) {
         methods.add(route.method);
         continue;
       }
-      if (route.pattern && route.pattern.exec(url2)) {
+      if (route.pattern && route.pattern.exec(url)) {
         methods.add(route.method);
         continue;
       }
-      if (route.path.endsWith("*") && url2.pathname.startsWith(route.path.slice(0, -1))) {
+      if (route.path.endsWith("*") && url.pathname.startsWith(route.path.slice(0, -1))) {
         methods.add(route.method);
       }
     }
@@ -8394,13 +6631,13 @@ class Router {
     return result;
   }
   matchRoute(path, method, domain) {
-    const url2 = new URL(path, "http://localhost");
-    const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
+    const url = new URL(path, "http://localhost");
+    const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
     if (this.routeCache.has(cacheKey)) {
       return this.routeCache.get(cacheKey);
     }
     if (this.staticRoutes.has(method)) {
-      const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
+      const staticRoute = this.staticRoutes.get(method).get(url.pathname);
       if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
         const result = {
           route: staticRoute,
@@ -8413,7 +6650,7 @@ class Router {
     const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
     const methodRoutes = potentialRoutes.filter((route) => route.method === method);
     for (const route of methodRoutes) {
-      if (route.path === url2.pathname) {
+      if (route.path === url.pathname) {
         const result = {
           route,
           params: {}
@@ -8424,7 +6661,7 @@ class Router {
     }
     for (const route of methodRoutes) {
       if (route.pattern) {
-        const match = route.pattern.exec(url2);
+        const match = route.pattern.exec(url);
         if (match) {
           const result = {
             route,
@@ -8439,11 +6676,11 @@ class Router {
       const wildcardRoutes = this.domains[domain].filter((route) => route.method === method && route.path.endsWith("*"));
       for (const route of wildcardRoutes) {
         const basePath = route.path.slice(0, -1);
-        if (url2.pathname.startsWith(basePath)) {
+        if (url.pathname.startsWith(basePath)) {
           const result = {
             route,
             params: {
-              wildcard: url2.pathname.slice(basePath.length)
+              wildcard: url.pathname.slice(basePath.length)
             }
           };
           this.routeCache.set(cacheKey, result);
@@ -8454,11 +6691,11 @@ class Router {
     const globalWildcardRoutes = this.routes.filter((route) => route.method === method && route.path.endsWith("*") && (!domain || !route.domain));
     for (const route of globalWildcardRoutes) {
       const basePath = route.path.slice(0, -1);
-      if (url2.pathname.startsWith(basePath)) {
+      if (url.pathname.startsWith(basePath)) {
         const result = {
           route,
           params: {
-            wildcard: url2.pathname.slice(basePath.length)
+            wildcard: url.pathname.slice(basePath.length)
           }
         };
         this.routeCache.set(cacheKey, result);
@@ -8487,9 +6724,9 @@ class Router {
       }
       return parsedCookies;
     };
-    const url2 = new URL(req.url);
+    const url = new URL(req.url);
     const query = {};
-    url2.searchParams.forEach((value, key) => {
+    url.searchParams.forEach((value, key) => {
       query[key] = value;
     });
     const enhancedReq = {
@@ -8866,7 +7103,7 @@ class Router {
     }
     return this;
   }
-  async executeMiddleware(middleware2, request2, handler) {
+  async executeMiddleware(middleware2, request, handler) {
     if (middleware2.length === 0) {
       return handler();
     }
@@ -8876,7 +7113,7 @@ class Router {
         return handler();
       }
       const mw = middleware2[currentIndex++];
-      const result = await mw(request2, next);
+      const result = await mw(request, next);
       return result || new Response("No response from middleware", { status: 500 });
     };
     return next();
@@ -9038,16 +7275,16 @@ class RequestWithMacros {
   static macroAccessor(name, getter) {
     requestMacroRegistry.register(name, getter, true);
   }
-  static applyMacros(request2) {
+  static applyMacros(request) {
     const epoch = requestMacroRegistry.getEpoch();
     if (epoch !== macroProtoEpoch) {
       macroProtoCache = new WeakMap;
       macroProtoEpoch = epoch;
     }
-    let base = Object.getPrototypeOf(request2) ?? Object.prototype;
+    let base = Object.getPrototypeOf(request) ?? Object.prototype;
     if (base[MACRO_PROTO]) {
       if (macroProtoCache.get(base[MACRO_BASE]) === base) {
-        return request2;
+        return request;
       }
       base = base[MACRO_BASE];
     }
@@ -9076,8 +7313,8 @@ class RequestWithMacros {
       Object.defineProperty(proto, MACRO_BASE, { value: base });
       macroProtoCache.set(base, proto);
     }
-    Object.setPrototypeOf(request2, proto);
-    return request2;
+    Object.setPrototypeOf(request, proto);
+    return request;
   }
   static hasMacro(name) {
     return requestMacroRegistry.has(name);
@@ -9271,8 +7508,8 @@ var BuiltInRequestMacros = {
     return this.url;
   },
   root() {
-    const url2 = getParsedURL(this);
-    return `${url2.protocol}//${url2.host}`;
+    const url = getParsedURL(this);
+    return `${url.protocol}//${url.host}`;
   },
   is(pattern) {
     const path = this.path();
@@ -9291,11 +7528,11 @@ var BuiltInRequestMacros = {
     return this.routeName || null;
   },
   fingerprint() {
-    const url2 = getParsedURL(this);
+    const url = getParsedURL(this);
     const data = {
       method: this.method,
-      path: url2.pathname,
-      query: url2.search,
+      path: url.pathname,
+      query: url.search,
       ip: BuiltInRequestMacros.ip.call(this)
     };
     return btoa(JSON.stringify(data));
@@ -9346,6 +7583,36 @@ function registerBuiltInRequestMacros() {
 }
 registerBuiltInRequestMacros();
 
+// src/request/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var storage = new AsyncLocalStorage;
+var contextEnabled = false;
+var syncCurrent = null;
+function runWithRequest(initial, fn) {
+  if (!contextEnabled) {
+    syncCurrent = initial;
+    const result = fn();
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        syncCurrent = null;
+      });
+    }
+    syncCurrent = null;
+    return result;
+  }
+  return storage.run({ current: initial }, fn);
+}
+function setCurrentRequest(req) {
+  const store = storage.getStore();
+  if (store) {
+    store.current = req;
+    return;
+  }
+  if (syncCurrent !== null) {
+    syncCurrent = req;
+  }
+}
+
 // src/router/server.ts
 if (!RequestWithMacros.hasMacro("getParam")) {
   RequestWithMacros.macro("getParam", function(name, defaultValue) {
@@ -9631,10 +7898,10 @@ function registerServerHandling(RouterClass) {
     handleRequestImpl: {
       async value(req) {
         try {
-          const url2 = new URL(req.url);
-          req._parsedURL = url2;
-          const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-          const match = this.matchRoute(url2.pathname, req.method, hostname);
+          const url = new URL(req.url);
+          req._parsedURL = url;
+          const hostname = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+          const match = this.matchRoute(url.pathname, req.method, hostname);
           if (req.method === "OPTIONS" && !match) {
             const origin = req.headers.get("origin");
             const preflightHeaders = {
@@ -9654,7 +7921,7 @@ function registerServerHandling(RouterClass) {
           }
           const enhancedReq = this.enhanceRequest(req, {});
           setCurrentRequest(enhancedReq);
-          const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
+          const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
           const corsHeaders = {
             "Content-Type": "application/json",
             "Access-Control-Allow-Origin": "*",
@@ -9666,7 +7933,7 @@ function registerServerHandling(RouterClass) {
               return new Response(JSON.stringify({
                 success: false,
                 message: "Method Not Allowed",
-                path: url2.pathname,
+                path: url.pathname,
                 method: req.method,
                 allowed: allowedMethods
               }), {
@@ -9690,7 +7957,7 @@ function registerServerHandling(RouterClass) {
             return new Response(JSON.stringify({
               success: false,
               message: "Not Found",
-              path: url2.pathname,
+              path: url.pathname,
               method: req.method
             }), { status: 404, headers: corsHeaders });
           };
@@ -9985,34 +8252,34 @@ function registerWebSocketHandling(RouterClass) {
       configurable: true
     },
     upgrade: {
-      value(request2, options) {
+      value(request, options) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot upgrade to WebSocket");
         }
         if (!this.wsConfig) {
           throw new Error("WebSocket configuration not set, use router.websocket() to configure");
         }
-        return this.serverInstance.upgrade(request2, options);
+        return this.serverInstance.upgrade(request, options);
       },
       writable: true,
       configurable: true
     },
     timeout: {
-      value(request2, seconds) {
+      value(request, seconds) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot set timeout");
         }
-        this.serverInstance.timeout(request2, seconds);
+        this.serverInstance.timeout(request, seconds);
       },
       writable: true,
       configurable: true
     },
     requestIP: {
-      value(request2) {
+      value(request) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot get request IP");
         }
-        return this.serverInstance.requestIP(request2);
+        return this.serverInstance.requestIP(request);
       },
       writable: true,
       configurable: true
@@ -10020,7 +8287,7 @@ function registerWebSocketHandling(RouterClass) {
   });
 }
 // src/response/macros.ts
-import process4 from "process";
+import process3 from "process";
 
 class ResponseMacroRegistry {
   macros = new Map;
@@ -10201,16 +8468,16 @@ var BuiltInResponseMacros = {
       }
     });
   },
-  redirect: (url2, status = 302) => {
+  redirect: (url, status = 302) => {
     return new Response(null, {
       status,
       headers: {
-        Location: url2
+        Location: url
       }
     });
   },
-  permanentRedirect: (url2) => {
-    return BuiltInResponseMacros.redirect(url2, 301);
+  permanentRedirect: (url) => {
+    return BuiltInResponseMacros.redirect(url, 301);
   },
   download: (data, filename, contentType = "application/octet-stream") => {
     return new Response(data, {
@@ -10281,7 +8548,7 @@ var BuiltInResponseMacros = {
       status,
       timestamp: new Date().toISOString(),
       checks,
-      uptime: process4.uptime?.() || 0
+      uptime: process3.uptime?.() || 0
     };
     return new Response(JSON.stringify(response2), {
       status: statusCode,
@@ -10345,8 +8612,8 @@ var BuiltInRules = {
     name: "url",
     validate: (value) => {
       try {
-        const url2 = new URL(value);
-        return Boolean(url2);
+        const url = new URL(value);
+        return Boolean(url);
       } catch {
         return false;
       }
@@ -11005,119 +9272,6 @@ registerRouteBuilding(Router);
 registerModelBinding(Router);
 registerFileBasedRouting(Router);
 registerApiRoutes(Router);
-// src/router/middleware-groups.ts
-class MiddlewareGroupRegistry {
-  groups = new Map;
-  globalMiddleware = [];
-  middlewarePriority = new Map;
-  define(name, middleware2) {
-    this.groups.set(name, [...middleware2]);
-    return this;
-  }
-  extend(name, middleware2) {
-    const existing = this.groups.get(name) || [];
-    this.groups.set(name, [...existing, ...middleware2]);
-    return this;
-  }
-  prepend(name, middleware2) {
-    const existing = this.groups.get(name) || [];
-    this.groups.set(name, [...middleware2, ...existing]);
-    return this;
-  }
-  get(name) {
-    return this.groups.get(name) || [];
-  }
-  has(name) {
-    return this.groups.has(name);
-  }
-  remove(name) {
-    this.groups.delete(name);
-    return this;
-  }
-  resolve(middleware2) {
-    if (typeof middleware2 === "function") {
-      return [middleware2];
-    }
-    if (this.groups.has(middleware2)) {
-      return this.get(middleware2);
-    }
-    return [middleware2];
-  }
-  resolveAll(middleware2) {
-    const resolved = [];
-    for (const mw of middleware2) {
-      resolved.push(...this.resolve(mw));
-    }
-    return resolved;
-  }
-  pushGlobal(...middleware2) {
-    this.globalMiddleware.push(...middleware2);
-    return this;
-  }
-  prependGlobal(...middleware2) {
-    this.globalMiddleware.unshift(...middleware2);
-    return this;
-  }
-  removeGlobal(middleware2) {
-    this.globalMiddleware = this.globalMiddleware.filter((mw) => typeof mw === "string" ? mw !== middleware2 : true);
-    return this;
-  }
-  getGlobal() {
-    return [...this.globalMiddleware];
-  }
-  setPriority(name, priority) {
-    this.middlewarePriority.set(name, priority);
-    return this;
-  }
-  sortByPriority(middleware2) {
-    return [...middleware2].sort((a, b) => {
-      const nameA = typeof a === "string" ? a.split(":")[0] : "";
-      const nameB = typeof b === "string" ? b.split(":")[0] : "";
-      const priorityA = this.middlewarePriority.get(nameA) ?? 100;
-      const priorityB = this.middlewarePriority.get(nameB) ?? 100;
-      return priorityA - priorityB;
-    });
-  }
-  filter(middleware2, options) {
-    if (options.only && options.only.length > 0) {
-      return middleware2.filter((mw) => {
-        if (typeof mw === "string") {
-          const name = mw.split(":")[0];
-          return options.only.includes(name);
-        }
-        return false;
-      });
-    }
-    if (options.except && options.except.length > 0) {
-      return middleware2.filter((mw) => {
-        if (typeof mw === "string") {
-          const name = mw.split(":")[0];
-          return !options.except.includes(name);
-        }
-        return true;
-      });
-    }
-    return middleware2;
-  }
-  flush() {
-    this.groups.clear();
-    this.globalMiddleware = [];
-    this.middlewarePriority.clear();
-  }
-}
-var middlewareGroups = new MiddlewareGroupRegistry;
-middlewareGroups.define("web", ["session", "csrf", "cors"]);
-middlewareGroups.define("api", ["throttle:60,1", "cors"]);
-middlewareGroups.setPriority("session", 10);
-middlewareGroups.setPriority("cors", 20);
-middlewareGroups.setPriority("csrf", 30);
-middlewareGroups.setPriority("auth", 40);
-middlewareGroups.setPriority("throttle", 50);
-middlewareGroups.setPriority("role", 60);
-middlewareGroups.setPriority("permission", 60);
-middlewareGroups.setPriority("can", 70);
-middlewareGroups.setPriority("abilities", 70);
-middlewareGroups.setPriority("verified", 80);
 // src/testing/auth-testing.ts
 import { mock } from "bun:test";
 
@@ -11336,8 +9490,8 @@ function createCookieAccessor2(cookies) {
 
 class AuthTester {
   request;
-  constructor(request2) {
-    this.request = request2 || createMockRequest();
+  constructor(request) {
+    this.request = request || createMockRequest();
   }
   as(user) {
     this.request.user = user;
@@ -11565,16 +9719,16 @@ var authMocks = {
   })
 };
 var authHelpers = {
-  authenticatedRequest: (user, request2) => {
-    return new AuthTester(request2).as(user).getRequest();
+  authenticatedRequest: (user, request) => {
+    return new AuthTester(request).as(user).getRequest();
   },
-  jwtRequest: (payload = {}, request2) => {
+  jwtRequest: (payload = {}, request) => {
     const jwt = new JWTTester;
     const token = jwt.generateToken(payload);
-    return new AuthTester(request2).withJWT(token).getRequest();
+    return new AuthTester(request).withJWT(token).getRequest();
   },
-  sessionRequest: (sessionData = {}, request2) => {
-    return new AuthTester(request2).withSession(sessionData).getRequest();
+  sessionRequest: (sessionData = {}, request) => {
+    return new AuthTester(request).withSession(sessionData).getRequest();
   },
   verifyJWTStructure: (token) => {
     const parts = token.split(".");
@@ -11589,8 +9743,8 @@ var authHelpers = {
     }
   }
 };
-function createAuthTester(request2) {
-  return new AuthTester(request2);
+function createAuthTester(request) {
+  return new AuthTester(request);
 }
 function createJWTTester(options) {
   return new JWTTester(options);
@@ -11598,13 +9752,14 @@ function createJWTTester(options) {
 function createSessionTester(options) {
   return new SessionTester(options);
 }
+
 // src/testing/file-upload-testing.ts
 import { mock as mock2 } from "bun:test";
 class FileUploadTester {
   request;
   files;
-  constructor(request2) {
-    this.request = request2 || createMockRequest();
+  constructor(request) {
+    this.request = request || createMockRequest();
     this.files = [];
   }
   addFile(testFile) {
@@ -11836,8 +9991,8 @@ var fileUploadScenarios = {
   }
 };
 var fileUploadAssertions = {
-  hasFiles: (request2, count) => {
-    const files = request2.files || [];
+  hasFiles: (request, count) => {
+    const files = request.files || [];
     if (count !== undefined && files.length !== count) {
       throw new Error(`Expected ${count} files, but got ${files.length}`);
     }
@@ -11845,8 +10000,8 @@ var fileUploadAssertions = {
       throw new Error("Expected request to have files");
     }
   },
-  hasFileWithField: (request2, fieldName) => {
-    const files = request2.files || [];
+  hasFileWithField: (request, fieldName) => {
+    const files = request.files || [];
     const hasField = files.some((file) => file.fieldName === fieldName);
     if (!hasField) {
       throw new Error(`Expected file with field name '${fieldName}'`);
@@ -11870,8 +10025,8 @@ var fileUploadAssertions = {
     }
   }
 };
-function createFileUploadTester(request2) {
-  return new FileUploadTester(request2);
+function createFileUploadTester(request) {
+  return new FileUploadTester(request);
 }
 var testFiles = {
   image: (fieldName = "image", filename = "test.jpg") => ({
@@ -11905,6 +10060,7 @@ var testFiles = {
     mimetype: "application/x-executable"
   })
 };
+
 // src/testing/middleware-testing.ts
 import { mock as mock3, spyOn } from "bun:test";
 class MiddlewareTester {
@@ -11915,15 +10071,15 @@ class MiddlewareTester {
     this.context = this.createContext();
   }
   createContext() {
-    const request2 = createMockRequest();
+    const request = createMockRequest();
     const next = mock3(() => Promise.resolve(new Response("Next called", { status: 200 })));
     return {
-      request: request2,
+      request,
       next
     };
   }
-  withRequest(request2) {
-    this.context.request = request2;
+  withRequest(request) {
+    this.context.request = request;
     return this;
   }
   withNext(nextFn) {
@@ -12021,8 +10177,8 @@ class MiddlewareChainTester {
     this.request = createMockRequest();
     this.finalHandler = mock3(async () => new Response("Final handler", { status: 200 }));
   }
-  withRequest(request2) {
-    this.request = request2;
+  withRequest(request) {
+    this.request = request;
     return this;
   }
   withFinalHandler(handler) {
@@ -12062,11 +10218,11 @@ function createMiddlewareSpy() {
 }
 async function benchmarkMiddleware(middleware2, iterations = 1000) {
   const times = [];
-  const request2 = createMockRequest();
+  const request = createMockRequest();
   const next = mock3(async () => new Response("OK"));
   for (let i = 0;i < iterations; i++) {
     const start = performance.now();
-    await middleware2(request2, next);
+    await middleware2(request, next);
     const end = performance.now();
     times.push(end - start);
   }
@@ -12081,6 +10237,7 @@ async function benchmarkMiddleware(middleware2, iterations = 1000) {
     totalTime
   };
 }
+
 // src/testing/model-binding-testing.ts
 import { mock as mock4 } from "bun:test";
 class GenericMockModel {
@@ -12164,8 +10321,8 @@ class ModelBindingTester {
     this.options = options;
     this.request = createMockRequest();
   }
-  withRequest(request2) {
-    this.request = request2;
+  withRequest(request) {
+    this.request = request;
     return this;
   }
   withParams(params) {
@@ -12303,18 +10460,18 @@ var modelMocks = {
 };
 var constraintHelpers = {
   belongsTo: (userIdField = "userId") => {
-    const fn = async (model, request2) => {
-      if (!request2.user)
+    const fn = async (model, request) => {
+      if (!request.user)
         return false;
-      return model[userIdField] === request2.user.id;
+      return model[userIdField] === request.user.id;
     };
     return mock4(fn);
   },
   belongsToUser: () => {
-    const fn = async (model, request2) => {
-      if (!request2.user)
+    const fn = async (model, request) => {
+      if (!request.user)
         return false;
-      return model.userId === request2.user.id;
+      return model.userId === request.user.id;
     };
     return mock4(fn);
   },
@@ -12334,9 +10491,9 @@ var constraintHelpers = {
     return mock4(constraintFn);
   },
   combine: (...constraints) => {
-    const fn = async (model, request2) => {
+    const fn = async (model, request) => {
       for (const constraint of constraints) {
-        if (!await constraint(model, request2)) {
+        if (!await constraint(model, request)) {
           return false;
         }
       }
@@ -12393,24 +10550,24 @@ class ModelResolverTester {
 }
 var routeModelHelpers = {
   testRoute: async (path, params, modelBindings) => {
-    const request2 = createMockRequest("GET", path);
-    request2.params = params;
+    const request = createMockRequest("GET", path);
+    request.params = params;
     for (const [key, model] of Object.entries(modelBindings)) {
-      request2.context = request2.context || {};
-      request2.context[key] = model;
+      request.context = request.context || {};
+      request.context[key] = model;
     }
-    return request2;
+    return request;
   },
   createHandler: (expectedModels) => {
-    const fn = async (request2) => {
-      const context = request2.context || {};
+    const fn = async (request) => {
+      const context = request.context || {};
       for (const modelKey of expectedModels) {
         if (!context[modelKey]) {
           return new Response(`Model ${modelKey} not found`, { status: 404 });
         }
       }
       return new Response(JSON.stringify({
-        params: request2.params,
+        params: request.params,
         models: Object.fromEntries(expectedModels.map((key) => [key, context[key]]))
       }), {
         headers: { "Content-Type": "application/json" }
@@ -12419,16 +10576,16 @@ var routeModelHelpers = {
     return mock4(fn);
   },
   testBindingMiddleware: (bindings) => {
-    const fn = async (request2, next) => {
-      request2.context = request2.context || {};
+    const fn = async (request, next) => {
+      request.context = request.context || {};
       for (const [key, resolver] of Object.entries(bindings)) {
-        const paramValue = request2.params[key];
+        const paramValue = request.params[key];
         if (paramValue) {
           try {
             if (typeof resolver === "function") {
-              request2.context[key] = await resolver(paramValue);
+              request.context[key] = await resolver(paramValue);
             } else {
-              request2.context[key] = resolver;
+              request.context[key] = resolver;
             }
           } catch (error) {
             console.error(`Error resolving model ${key}:`, error);
@@ -12463,9 +10620,10 @@ var scopedBindingHelpers = {
     return requiredPermissions.every((permission) => user.permissions.includes(permission));
   }
 };
+
 // src/testing/performance-testing.ts
 import { mock as mock5 } from "bun:test";
-import process5 from "process";
+import process4 from "process";
 class PerformanceTester {
   metrics = [];
   startTime = 0;
@@ -12584,10 +10742,10 @@ class LoadTester {
 var benchmarkTests = {
   routeHandler: async (handler, iterations = 1000) => {
     const times = [];
-    const request2 = createMockRequest();
+    const request = createMockRequest();
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await handler(request2);
+      await handler(request);
       const end = performance.now();
       times.push(end - start);
     }
@@ -12606,11 +10764,11 @@ var benchmarkTests = {
   },
   middleware: async (middleware2, iterations = 1000) => {
     const times = [];
-    const request2 = createMockRequest();
+    const request = createMockRequest();
     const next = mock5(async () => new Response("OK"));
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await middleware2(request2, next);
+      await middleware2(request, next);
       const end = performance.now();
       times.push(end - start);
     }
@@ -12683,11 +10841,11 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const initialHeap = process5.memoryUsage().heapUsed;
+    const initialHeap = process4.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
       const result = await fn();
       results.push(result);
-      const memUsage = process5.memoryUsage();
+      const memUsage = process4.memoryUsage();
       heapUsages.push(memUsage.heapUsed);
       if (i % 10 === 0 && globalThis.gc) {
         globalThis.gc();
@@ -12696,7 +10854,7 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const finalHeap = process5.memoryUsage().heapUsed;
+    const finalHeap = process4.memoryUsage().heapUsed;
     const averageHeapUsed = heapUsages.reduce((sum, usage) => sum + usage, 0) / heapUsages.length;
     const maxHeapUsed = Math.max(...heapUsages);
     const memoryLeakDetected = finalHeap - initialHeap > 1024 * 1024;
@@ -12710,17 +10868,17 @@ var memoryTests = {
   testRouteHandlerMemoryLeaks: async (handler, iterations = 1000) => {
     if (globalThis.gc)
       globalThis.gc();
-    const initialMemory = process5.memoryUsage().heapUsed;
+    const initialMemory = process4.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
-      const request2 = createMockRequest();
-      await handler(request2);
+      const request = createMockRequest();
+      await handler(request);
       if (i % 100 === 0 && globalThis.gc) {
         globalThis.gc();
       }
     }
     if (globalThis.gc)
       globalThis.gc();
-    const finalMemory = process5.memoryUsage().heapUsed;
+    const finalMemory = process4.memoryUsage().heapUsed;
     const memoryGrowth = finalMemory - initialMemory;
     const memoryLeakDetected = memoryGrowth > 5 * 1024 * 1024;
     return {
@@ -12812,7 +10970,7 @@ function createLoadTester(client, config2) {
 }
 var performanceUtils = {
   getCurrentMemoryUsage: () => {
-    const usage = process5.memoryUsage();
+    const usage = process4.memoryUsage();
     return {
       heapUsed: usage.heapUsed,
       heapTotal: usage.heapTotal,
@@ -12821,7 +10979,7 @@ var performanceUtils = {
     };
   },
   getCPUUsage: () => {
-    const usage = process5.cpuUsage();
+    const usage = process4.cpuUsage();
     return {
       user: usage.user,
       system: usage.system
@@ -12836,6 +10994,7 @@ var performanceUtils = {
     return JSON.stringify(results, null, 2);
   }
 };
+
 // src/testing/test-response.ts
 class TestResponseWrapper {
   status;
@@ -12956,14 +11115,14 @@ class TestResponseWrapper {
     }
     return this;
   }
-  expectRedirect(url2) {
+  expectRedirect(url) {
     if (this.status < 300 || this.status >= 400) {
       throw new Error(`Expected redirect status (3xx), got ${this.status}`);
     }
-    if (url2) {
+    if (url) {
       const location = this.headers.location;
-      if (location !== url2) {
-        throw new Error(`Expected redirect to '${url2}', got '${location}'`);
+      if (location !== url) {
+        throw new Error(`Expected redirect to '${url}', got '${location}'`);
       }
     }
     return this;
@@ -13106,24 +11265,24 @@ class TestClient {
   async request(method, path, options = {}) {
     const headers = { ...this.defaultHeaders, ...options.headers };
     const requestOptions = { ...options, headers };
-    const request2 = new TestRequestBuilder(method, path, requestOptions).build();
+    const request = new TestRequestBuilder(method, path, requestOptions).build();
     try {
-      const response2 = await this.handleRequest(request2);
+      const response2 = await this.handleRequest(request);
       return await createTestResponse(response2);
     } catch (error) {
       throw new Error(`Test request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  async handleRequest(request2) {
-    const url2 = new URL(request2.url);
-    const matchResult = this.findMatchingRoute(request2.method, url2.pathname);
+  async handleRequest(request) {
+    const url = new URL(request.url);
+    const matchResult = this.findMatchingRoute(request.method, url.pathname);
     if (!matchResult) {
       return new Response("Not Found", { status: 404 });
     }
     const { route, params } = matchResult;
-    request2.params = { ...request2.params, ...params };
+    request.params = { ...request.params, ...params };
     try {
-      const response2 = await this.executeMiddlewareChain(request2, route);
+      const response2 = await this.executeMiddlewareChain(request, route);
       return response2 || new Response("No response", { status: 500 });
     } catch (error) {
       return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal Server Error" }), {
@@ -13163,28 +11322,28 @@ class TestClient {
     }
     return params;
   }
-  async executeMiddlewareChain(request2, route) {
+  async executeMiddlewareChain(request, route) {
     const middlewares = [...this.router.globalMiddleware, ...route.middleware];
     let index = 0;
     const next = async () => {
       if (index < middlewares.length) {
         const middleware2 = middlewares[index++];
-        return await middleware2(request2, next);
+        return await middleware2(request, next);
       } else {
-        return await this.executeHandler(route.handler, request2);
+        return await this.executeHandler(route.handler, request);
       }
     };
     const result = await next();
     return result || new Response("No response", { status: 500 });
   }
-  async executeHandler(handler, request2) {
+  async executeHandler(handler, request) {
     if (typeof handler === "function") {
-      return await handler(request2);
+      return await handler(request);
     } else if (typeof handler === "string") {
       throw new TypeError(`String handlers not supported in test environment: ${handler}`);
     } else if (typeof handler === "object" && handler.handle) {
       const instance = new handler;
-      return await instance.handle(request2);
+      return await instance.handle(request);
     }
     throw new Error("Invalid handler type");
   }
@@ -13225,6 +11384,7 @@ var testClient = {
   withAuth: (token, type = "Bearer") => (router2) => createTestClient(router2).auth(token, type),
   withHeaders: (headers) => (router2) => createTestClient(router2).withHeaders(headers)
 };
+
 // src/testing/websocket-testing.ts
 import { mock as mock6 } from "bun:test";
 
@@ -13579,13 +11739,13 @@ export {
   spyOnMiddleware,
   singleFileUpload,
   signRequest,
-  setCurrentRequest,
+  setCurrentRequest2 as setCurrentRequest,
   setContainer,
   session,
   securitySuite,
   security,
   scopedBindingHelpers,
-  runWithRequest,
+  runWithRequest2 as runWithRequest,
   rule,
   router,
   routeModelHelpers,
@@ -13598,7 +11758,7 @@ export {
   requestSigning,
   requestId,
   request,
-  registerNamedRoute,
+  registerNamedRoute2 as registerNamedRoute,
   rateLimitRegistry,
   rateLimit,
   processHtmlTemplate,
@@ -13628,7 +11788,7 @@ export {
   globalValidator,
   globalMiddlewarePipeline,
   getNamedRoutes,
-  getNamedRoutePath,
+  getNamedRoutePath2 as getNamedRoutePath,
   getCurrentRequest,
   getContainer,
   getConfig,
@@ -13759,7 +11919,7 @@ export {
   FileUpload,
   FileSessionStore,
   FileSecurity,
-  exports_errors as Errors,
+  Errors,
   EnvironmentManager,
   EnhancementPresets,
   DomainMatcher,
@@ -13779,6 +11939,6 @@ export {
   BuiltInRules,
   BindingBuilder,
   AuthTester,
-  auth_default as Auth,
+  default2 as Auth,
   ApiKeyManager
 };