@stacksjs/bun-router 0.0.19 → 0.0.21

package/dist/index.js

@@ -64,11 +64,48 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-y3xq6wq6.js";
+} from "./chunk-cgptvjdf.js";
 import {
-  ValidationException
-} from "./chunk-a8p83068.js";
-import"./chunk-2mx7fq49.js";
+  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";
+
 // src/auth.ts
 import { timingSafeEqual } from "crypto";
 function base64UrlEncode(str) {
@@ -215,123 +252,1800 @@ class ApiKeyManager {
       ...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
+  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
+    };
+    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 || ""
     });
-    return key;
-  }
-  validateKey(key, requiredScopes = []) {
-    const keyInfo = this.keys.get(key);
-    if (!keyInfo) {
-      return false;
+    if ("allowedMethods" in error) {
+      headers.set("Allow", error.allowedMethods.join(", "));
     }
-    if (keyInfo.expiresAt && keyInfo.expiresAt < new Date) {
-      return false;
+    if ("retryAfter" in error) {
+      headers.set("Retry-After", error.retryAfter.toString());
     }
-    if (requiredScopes.length > 0) {
-      return requiredScopes.every((scope) => keyInfo.scopes.includes(scope));
+    if ("limit" in error) {
+      headers.set("X-RateLimit-Limit", error.limit.toString());
+      headers.set("X-RateLimit-Remaining", error.remaining.toString());
     }
-    return true;
+    return new Response(JSON.stringify(errorResponse), {
+      status: error.statusCode,
+      headers
+    });
   }
-  getKeyInfo(key) {
-    return this.keys.get(key) || null;
+  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);
+    }
   }
-  revokeKey(key) {
-    return this.keys.delete(key);
+  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
+    };
   }
-  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;
+  async cleanup() {
+    if (this.errorReporting) {
+      await this.errorReporting.close();
+    }
+    if (this.gracefulDegradation) {
+      this.gracefulDegradation.stop();
     }
   }
-  randomString(length) {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    let result = "";
-    for (let i = 0;i < length; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
+}
+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;
+      });
     }
+    syncCurrent = null;
     return result;
   }
+  return storage.run({ current: initial }, fn);
 }
-
-class OAuth2Helper {
-  config;
-  constructor(config2) {
-    this.config = config2;
+function setCurrentRequest(req) {
+  const store = storage.getStore();
+  if (store) {
+    store.current = req;
+    return;
   }
-  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()}`;
+  if (syncCurrent !== null) {
+    syncCurrent = req;
   }
-  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();
+}
+function getCurrentRequest() {
+  if (!contextEnabled) {
+    contextEnabled = true;
+    return syncCurrent ?? undefined;
   }
-  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 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.");
   }
+  return req;
 }
 // src/response/response-factory.ts
 var response = {
@@ -429,8 +2143,8 @@ var response = {
   redirectTemporary: (url) => {
     return response.redirect(url, 302);
   },
-  back: (request, fallback = "/") => {
-    const referer = request.headers.get("referer") || fallback;
+  back: (request2, fallback = "/") => {
+    const referer = request2.headers.get("referer") || fallback;
     return response.redirect(referer);
   },
   view: (html, status = 200, headers = {}) => {
@@ -675,7 +2389,7 @@ class MiddlewarePipeline {
     }
     this.compiledPipelines.set(routeKey, compiled);
   }
-  async execute(routeKey, request, finalHandler) {
+  async execute(routeKey, request2, finalHandler) {
     const startTime = performance.now();
     this.stats.totalExecutions++;
     const pipeline = this.compiledPipelines.get(routeKey);
@@ -685,7 +2399,7 @@ class MiddlewarePipeline {
     }
     this.stats.cacheHits++;
     const context = {
-      request,
+      request: request2,
       dependencies: new Map,
       metadata: {}
     };
@@ -700,7 +2414,7 @@ class MiddlewarePipeline {
         this.stats.skippedMiddleware++;
         return await next();
       }
-      const result2 = await middleware2.handler(request, next);
+      const result2 = await middleware2.handler(request2, next);
       if (result2 instanceof Response && middleware2.canShortCircuit) {
         this.stats.shortCircuits++;
         return result2;
@@ -1778,12 +3492,12 @@ class StreamHandler {
   }
 }
 class FileStreamHandler {
-  static async streamFile(filePath, request, options = {}) {
+  static async streamFile(filePath, request2, options = {}) {
     const { contentType, enableRanges = true, chunkSize: _chunkSize = 64 * 1024 } = options;
     try {
       const file = Bun.file(filePath);
       const fileSize = file.size;
-      const range = enableRanges ? request.headers.get("range") : null;
+      const range = enableRanges ? request2.headers.get("range") : null;
       if (range && enableRanges) {
         return FileStreamHandler.handleRangeRequest(file, range, contentType);
       }
@@ -1862,8 +3576,8 @@ function closeReadableStreamAfterError(controller, error) {
 function registerFileStreaming(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     streamFile: {
-      value(filePath, request, options) {
-        return FileStreamHandler.streamFile(filePath, request, options);
+      value(filePath, request2, options) {
+        return FileStreamHandler.streamFile(filePath, request2, options);
       },
       writable: true,
       configurable: true
@@ -3218,6 +4932,7 @@ var SubdomainPatterns = {
 };
 
 // src/url.ts
+import process3 from "process";
 var namedRouteRegistry = new Map;
 function registerNamedRoute(name, path) {
   namedRouteRegistry.set(name, path);
@@ -3225,6 +4940,54 @@ 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";
@@ -3778,24 +5541,24 @@ class FluentRouter {
   getRoutes() {
     return [...this.routes, ...this.subdomainRouter.getAllRoutes()];
   }
-  async handle(request) {
-    const url = new URL(request.url);
-    const domain = url.hostname;
+  async handle(request2) {
+    const url2 = new URL(request2.url);
+    const domain = url2.hostname;
     const match = this.subdomainRouter.findDomainGroup(domain);
     if (match) {
-      const enhancedReq = request;
+      const enhancedReq = request2;
       enhancedReq.domainParams = match.parameters;
       for (const route of match.group.getRoutes()) {
-        const params = this.matchRouteParams(route, request.method, url.pathname);
+        const params = this.matchRouteParams(route, request2.method, url2.pathname);
         if (params) {
           return await this.executeRoute(route, enhancedReq, params);
         }
       }
     }
     for (const route of this.routes) {
-      const params = this.matchRouteParams(route, request.method, url.pathname);
+      const params = this.matchRouteParams(route, request2.method, url2.pathname);
       if (params) {
-        return await this.executeRoute(route, request, params);
+        return await this.executeRoute(route, request2, params);
       }
     }
     return null;
@@ -3807,11 +5570,11 @@ class FluentRouter {
     const params = {};
     return matchPath(route.path, pathname, params) ? params : null;
   }
-  async executeRoute(route, request, params) {
-    request.params = params;
+  async executeRoute(route, request2, params) {
+    request2.params = params;
     const allMiddleware = [...this.globalMiddleware];
     for (const conditional of this.conditionalMiddleware) {
-      if (await conditional.condition(request)) {
+      if (await conditional.condition(request2)) {
         allMiddleware.push(...conditional.middleware);
       }
     }
@@ -3820,10 +5583,10 @@ class FluentRouter {
     const next = async () => {
       if (index < allMiddleware.length) {
         const middleware2 = allMiddleware[index++];
-        const result = await middleware2(request, next);
+        const result = await middleware2(request2, next);
         return result ?? new Response(null);
       }
-      return await route.handler(request);
+      return await route.handler(request2);
     };
     return await next();
   }
@@ -3861,27 +5624,27 @@ var RouteFactory = {
 };
 var RouterUtils = {
   route: (name, params = {}, query = {}) => {
-    let url = getNamedRoutePath(name) ?? `/${name}`;
+    let url2 = getNamedRoutePath(name) ?? `/${name}`;
     for (const [key, value] of Object.entries(params)) {
       const encoded = encodeURIComponent(value);
-      url = url.replace(`{${key}}`, encoded);
-      url = url.replace(`{${key}?}`, encoded);
+      url2 = url2.replace(`{${key}}`, encoded);
+      url2 = url2.replace(`{${key}?}`, encoded);
     }
-    if (url.includes("?}")) {
-      url = url.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
-      if (url.length > 1 && url.endsWith("/"))
-        url = url.slice(0, -1);
+    if (url2.includes("?}")) {
+      url2 = url2.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
+      if (url2.length > 1 && url2.endsWith("/"))
+        url2 = url2.slice(0, -1);
     }
     const queryString = new URLSearchParams(query).toString();
     if (queryString) {
-      url += `?${queryString}`;
+      url2 += `?${queryString}`;
     }
-    return url;
+    return url2;
   },
-  redirect: (url, status = 302) => {
+  redirect: (url2, status = 302) => {
     return new Response(null, {
       status,
-      headers: { Location: url }
+      headers: { Location: url2 }
     });
   },
   json: (data, status = 200) => {
@@ -4079,10 +5842,10 @@ function registerHttpMethods(RouterClass) {
           route.constraints = constraints;
         }
         route.pattern = {
-          exec: (url) => {
+          exec: (url2) => {
             const params = {};
             const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-            const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
+            const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
             if (!isMatch) {
               return null;
             }
@@ -4209,18 +5972,18 @@ function registerHttpMethods(RouterClass) {
         if (!route) {
           throw new Error(`Route with name "${name}" not found`);
         }
-        let url = route.path;
+        let url2 = route.path;
         for (const [param, value] of Object.entries(params)) {
-          url = url.replace(`{${param}}`, encodeURIComponent(value));
-          url = url.replace(`{${param}?}`, encodeURIComponent(value));
+          url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
+          url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
         }
-        if (url.includes("{")) {
-          url = url.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
-          if (url.length > 1 && url.endsWith("/")) {
-            url = url.slice(0, -1);
+        if (url2.includes("{")) {
+          url2 = url2.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
+          if (url2.length > 1 && url2.endsWith("/")) {
+            url2 = url2.slice(0, -1);
           }
         }
-        return url;
+        return url2;
       },
       writable: true,
       configurable: true
@@ -4238,9 +6001,9 @@ function registerHttpMethods(RouterClass) {
 function registerRedirectMethods(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     redirect: {
-      value(url, status = 302) {
+      value(url2, status = 302) {
         const headers = new Headers;
-        headers.set("Location", url);
+        headers.set("Location", url2);
         return new Response(null, {
           status,
           headers
@@ -4250,8 +6013,8 @@ function registerRedirectMethods(RouterClass) {
       configurable: true
     },
     permanentRedirect: {
-      value(url) {
-        return this.redirect(url, 301);
+      value(url2) {
+        return this.redirect(url2, 301);
       },
       writable: true,
       configurable: true
@@ -5249,8 +7012,8 @@ class RouteCompiler {
       }
       const pattern = this.convertToURLPattern(route.path, route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined);
       const urlPatternAdapter = {
-        exec: (url) => {
-          const pathname = url.pathname;
+        exec: (url2) => {
+          const pathname = url2.pathname;
           const result = pattern.exec(pathname);
           if (!result)
             return null;
@@ -5621,8 +7384,8 @@ function registerOptimizedRouteMatching(RouterClass) {
     },
     fallbackMatchRoute: {
       value(path, method, domain) {
-        const url = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+        const url2 = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
@@ -5630,7 +7393,7 @@ function registerOptimizedRouteMatching(RouterClass) {
           this.routeCache.clear();
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -5643,7 +7406,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 === url.pathname) {
+          if (route.path === url2.pathname) {
             const result = {
               route,
               params: {}
@@ -5654,7 +7417,7 @@ function registerOptimizedRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url);
+            const match = route.pattern.exec(url2);
             if (match) {
               const result = {
                 route,
@@ -5672,10 +7435,10 @@ function registerOptimizedRouteMatching(RouterClass) {
               continue;
             }
             const basePath = route.path.slice(0, -1);
-            if (url.pathname.startsWith(basePath)) {
+            if (url2.pathname.startsWith(basePath)) {
               const result = {
                 route,
-                params: { wildcard: url.pathname.slice(basePath.length) }
+                params: { wildcard: url2.pathname.slice(basePath.length) }
               };
               this.routeCache.set(cacheKey, result);
               return result;
@@ -5797,10 +7560,10 @@ function registerRouteBuilding(RouterClass) {
               } catch {}
             }
             bunRoutes[path] = async (req) => {
-              const url = new URL(req.url);
+              const url2 = new URL(req.url);
               const params = {};
               const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-              matchPath(path, url.pathname, params, constraintsRecord);
+              matchPath(path, url2.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];
@@ -5812,10 +7575,10 @@ function registerRouteBuilding(RouterClass) {
             for (const route of routes) {
               const method = route.method;
               methodHandlers[method] = async (req) => {
-                const url = new URL(req.url);
+                const url2 = new URL(req.url);
                 const params = {};
                 const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-                matchPath(path, url.pathname, params, constraintsRecord);
+                matchPath(path, url2.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];
@@ -5909,13 +7672,13 @@ function registerRouteMatching(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     matchRoute: {
       value(path, method, domain) {
-        const url = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+        const url2 = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -5928,7 +7691,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 === url.pathname) {
+          if (route.path === url2.pathname) {
             const result = {
               route,
               params: {}
@@ -5939,7 +7702,7 @@ function registerRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url);
+            const match = route.pattern.exec(url2);
             if (match) {
               const result = {
                 route,
@@ -5954,11 +7717,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 (url.pathname.startsWith(basePath)) {
+            if (url2.pathname.startsWith(basePath)) {
               const result = {
                 route,
                 params: {
-                  wildcard: url.pathname.slice(basePath.length)
+                  wildcard: url2.pathname.slice(basePath.length)
                 }
               };
               this.routeCache.set(cacheKey, result);
@@ -5969,11 +7732,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 (url.pathname.startsWith(basePath)) {
+          if (url2.pathname.startsWith(basePath)) {
             const result = {
               route,
               params: {
-                wildcard: url.pathname.slice(basePath.length)
+                wildcard: url2.pathname.slice(basePath.length)
               }
             };
             this.routeCache.set(cacheKey, result);
@@ -6074,9 +7837,9 @@ function registerRouteMatching(RouterClass) {
           const routePath = lastRoute.path;
           const constraintsRecord = lastRoute.constraints && !Array.isArray(lastRoute.constraints) ? lastRoute.constraints : undefined;
           lastRoute.pattern = {
-            exec: (url) => {
+            exec: (url2) => {
               const params2 = {};
-              const isMatch = matchPath(routePath, url.pathname, params2, constraintsRecord);
+              const isMatch = matchPath(routePath, url2.pathname, params2, constraintsRecord);
               if (!isMatch) {
                 return null;
               }
@@ -6327,10 +8090,10 @@ class Router {
       route.constraints = constraints;
     }
     route.pattern = {
-      exec: (url) => {
+      exec: (url2) => {
         const params = {};
         const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-        const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
+        const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
         if (!isMatch) {
           return null;
         }
@@ -6411,27 +8174,27 @@ class Router {
     if (!route) {
       throw new Error(`Route with name "${name}" not found`);
     }
-    let url = route.path;
+    let url2 = route.path;
     for (const [param, value] of Object.entries(params)) {
-      url = url.replace(`{${param}}`, encodeURIComponent(value));
-      url = url.replace(`{${param}?}`, encodeURIComponent(value));
+      url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
+      url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
     }
-    return url;
+    return url2;
   }
   onError(handler) {
     this.errorHandler = handler;
     return this;
   }
-  redirect(url, status = 302) {
+  redirect(url2, status = 302) {
     const headers = new Headers;
-    headers.set("Location", url);
+    headers.set("Location", url2);
     return new Response(null, {
       status,
       headers
     });
   }
-  permanentRedirect(url) {
-    return this.redirect(url, 301);
+  permanentRedirect(url2) {
+    return this.redirect(url2, 301);
   }
   redirectRoute(from, to, status = 302) {
     this.get(from, (_req) => {
@@ -6458,13 +8221,13 @@ class Router {
   }
   async handleRequest(req) {
     try {
-      const url = new URL(req.url);
+      const url2 = new URL(req.url);
       if (this.config.verbose) {
-        console.log(`${req.method} ${url.pathname}`);
+        console.log(`${req.method} ${url2.pathname}`);
       }
       if (req.method === "OPTIONS") {
-        const hostname2 = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-        const optionsMatch = this.matchRoute(url.pathname, "OPTIONS", hostname2);
+        const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+        const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
         if (!optionsMatch) {
           return new Response(null, {
             status: 204,
@@ -6477,8 +8240,8 @@ class Router {
           });
         }
       }
-      const hostname = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-      const match = this.matchRoute(url.pathname, req.method, hostname);
+      const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+      const match = this.matchRoute(url2.pathname, req.method, hostname);
       const enhancedReq = this.enhanceRequest(req, match?.params || {});
       if (match) {
         enhancedReq.route = match.route;
@@ -6496,12 +8259,12 @@ class Router {
         }
         return new Response("No response from middleware chain", { status: 500 });
       }
-      const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
+      const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
       if (allowedMethods.length > 0) {
         const methodNotAllowedHandler = async (_req, _next) => {
           return new Response(JSON.stringify({
             error: "Method Not Allowed",
-            path: url.pathname,
+            path: url2.pathname,
             method: req.method,
             allowed: allowedMethods
           }), {
@@ -6528,7 +8291,7 @@ class Router {
           }
           return new Response(JSON.stringify({
             error: "Not Found",
-            path: url.pathname,
+            path: url2.pathname,
             method: req.method
           }), {
             status: 404,
@@ -6547,7 +8310,7 @@ class Router {
       }
       return new Response(JSON.stringify({
         error: "Not Found",
-        path: url.pathname,
+        path: url2.pathname,
         method: req.method
       }), {
         status: 404,
@@ -6590,15 +8353,15 @@ class Router {
     }
   }
   getAllowedMethods(path, domain) {
-    const url = new URL(path, "http://localhost");
-    const cacheKey = `${domain || ""}:${url.pathname}`;
+    const url2 = new URL(path, "http://localhost");
+    const cacheKey = `${domain || ""}:${url2.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(url.pathname);
+      const staticRoute = routesByPath.get(url2.pathname);
       if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
         methods.add(method);
       }
@@ -6608,15 +8371,15 @@ class Router {
       if (methods.has(route.method)) {
         continue;
       }
-      if (route.path === url.pathname) {
+      if (route.path === url2.pathname) {
         methods.add(route.method);
         continue;
       }
-      if (route.pattern && route.pattern.exec(url)) {
+      if (route.pattern && route.pattern.exec(url2)) {
         methods.add(route.method);
         continue;
       }
-      if (route.path.endsWith("*") && url.pathname.startsWith(route.path.slice(0, -1))) {
+      if (route.path.endsWith("*") && url2.pathname.startsWith(route.path.slice(0, -1))) {
         methods.add(route.method);
       }
     }
@@ -6631,13 +8394,13 @@ class Router {
     return result;
   }
   matchRoute(path, method, domain) {
-    const url = new URL(path, "http://localhost");
-    const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+    const url2 = new URL(path, "http://localhost");
+    const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
     if (this.routeCache.has(cacheKey)) {
       return this.routeCache.get(cacheKey);
     }
     if (this.staticRoutes.has(method)) {
-      const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+      const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
       if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
         const result = {
           route: staticRoute,
@@ -6650,7 +8413,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 === url.pathname) {
+      if (route.path === url2.pathname) {
         const result = {
           route,
           params: {}
@@ -6661,7 +8424,7 @@ class Router {
     }
     for (const route of methodRoutes) {
       if (route.pattern) {
-        const match = route.pattern.exec(url);
+        const match = route.pattern.exec(url2);
         if (match) {
           const result = {
             route,
@@ -6676,11 +8439,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 (url.pathname.startsWith(basePath)) {
+        if (url2.pathname.startsWith(basePath)) {
           const result = {
             route,
             params: {
-              wildcard: url.pathname.slice(basePath.length)
+              wildcard: url2.pathname.slice(basePath.length)
             }
           };
           this.routeCache.set(cacheKey, result);
@@ -6691,11 +8454,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 (url.pathname.startsWith(basePath)) {
+      if (url2.pathname.startsWith(basePath)) {
         const result = {
           route,
           params: {
-            wildcard: url.pathname.slice(basePath.length)
+            wildcard: url2.pathname.slice(basePath.length)
           }
         };
         this.routeCache.set(cacheKey, result);
@@ -6724,9 +8487,9 @@ class Router {
       }
       return parsedCookies;
     };
-    const url = new URL(req.url);
+    const url2 = new URL(req.url);
     const query = {};
-    url.searchParams.forEach((value, key) => {
+    url2.searchParams.forEach((value, key) => {
       query[key] = value;
     });
     const enhancedReq = {
@@ -6930,6 +8693,13 @@ class Router {
       const value = params?.[name];
       return value !== undefined ? value : defaultValue;
     };
+    enhancedReq.getParamAsInt = (name) => {
+      const value = params?.[name];
+      if (value === undefined || value.trim() === "")
+        return null;
+      const parsed = Number(value);
+      return Number.isSafeInteger(parsed) ? parsed : null;
+    };
     enhancedReq.params = params || {};
     return enhancedReq;
   }
@@ -7103,7 +8873,7 @@ class Router {
     }
     return this;
   }
-  async executeMiddleware(middleware2, request, handler) {
+  async executeMiddleware(middleware2, request2, handler) {
     if (middleware2.length === 0) {
       return handler();
     }
@@ -7113,7 +8883,7 @@ class Router {
         return handler();
       }
       const mw = middleware2[currentIndex++];
-      const result = await mw(request, next);
+      const result = await mw(request2, next);
       return result || new Response("No response from middleware", { status: 500 });
     };
     return next();
@@ -7275,16 +9045,16 @@ class RequestWithMacros {
   static macroAccessor(name, getter) {
     requestMacroRegistry.register(name, getter, true);
   }
-  static applyMacros(request) {
+  static applyMacros(request2) {
     const epoch = requestMacroRegistry.getEpoch();
     if (epoch !== macroProtoEpoch) {
       macroProtoCache = new WeakMap;
       macroProtoEpoch = epoch;
     }
-    let base = Object.getPrototypeOf(request) ?? Object.prototype;
+    let base = Object.getPrototypeOf(request2) ?? Object.prototype;
     if (base[MACRO_PROTO]) {
       if (macroProtoCache.get(base[MACRO_BASE]) === base) {
-        return request;
+        return request2;
       }
       base = base[MACRO_BASE];
     }
@@ -7313,8 +9083,8 @@ class RequestWithMacros {
       Object.defineProperty(proto, MACRO_BASE, { value: base });
       macroProtoCache.set(base, proto);
     }
-    Object.setPrototypeOf(request, proto);
-    return request;
+    Object.setPrototypeOf(request2, proto);
+    return request2;
   }
   static hasMacro(name) {
     return requestMacroRegistry.has(name);
@@ -7508,8 +9278,8 @@ var BuiltInRequestMacros = {
     return this.url;
   },
   root() {
-    const url = getParsedURL(this);
-    return `${url.protocol}//${url.host}`;
+    const url2 = getParsedURL(this);
+    return `${url2.protocol}//${url2.host}`;
   },
   is(pattern) {
     const path = this.path();
@@ -7528,11 +9298,11 @@ var BuiltInRequestMacros = {
     return this.routeName || null;
   },
   fingerprint() {
-    const url = getParsedURL(this);
+    const url2 = getParsedURL(this);
     const data = {
       method: this.method,
-      path: url.pathname,
-      query: url.search,
+      path: url2.pathname,
+      query: url2.search,
       ip: BuiltInRequestMacros.ip.call(this)
     };
     return btoa(JSON.stringify(data));
@@ -7583,36 +9353,6 @@ 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) {
@@ -7620,6 +9360,15 @@ if (!RequestWithMacros.hasMacro("getParam")) {
     return value !== undefined ? value : defaultValue;
   });
 }
+if (!RequestWithMacros.hasMacro("getParamAsInt")) {
+  RequestWithMacros.macro("getParamAsInt", function(name) {
+    const value = this.params?.[name];
+    if (value === undefined || value.trim() === "")
+      return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+  });
+}
 if (!RequestWithMacros.hasMacro("get")) {
   RequestWithMacros.macro("get", function(key, defaultValue) {
     const value = getParsedURL(this).searchParams.get(key);
@@ -7898,10 +9647,10 @@ function registerServerHandling(RouterClass) {
     handleRequestImpl: {
       async value(req) {
         try {
-          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);
+          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);
           if (req.method === "OPTIONS" && !match) {
             const origin = req.headers.get("origin");
             const preflightHeaders = {
@@ -7921,7 +9670,7 @@ function registerServerHandling(RouterClass) {
           }
           const enhancedReq = this.enhanceRequest(req, {});
           setCurrentRequest(enhancedReq);
-          const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
+          const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
           const corsHeaders = {
             "Content-Type": "application/json",
             "Access-Control-Allow-Origin": "*",
@@ -7933,7 +9682,7 @@ function registerServerHandling(RouterClass) {
               return new Response(JSON.stringify({
                 success: false,
                 message: "Method Not Allowed",
-                path: url.pathname,
+                path: url2.pathname,
                 method: req.method,
                 allowed: allowedMethods
               }), {
@@ -7957,7 +9706,7 @@ function registerServerHandling(RouterClass) {
             return new Response(JSON.stringify({
               success: false,
               message: "Not Found",
-              path: url.pathname,
+              path: url2.pathname,
               method: req.method
             }), { status: 404, headers: corsHeaders });
           };
@@ -8252,34 +10001,34 @@ function registerWebSocketHandling(RouterClass) {
       configurable: true
     },
     upgrade: {
-      value(request, options) {
+      value(request2, 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(request, options);
+        return this.serverInstance.upgrade(request2, options);
       },
       writable: true,
       configurable: true
     },
     timeout: {
-      value(request, seconds) {
+      value(request2, seconds) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot set timeout");
         }
-        this.serverInstance.timeout(request, seconds);
+        this.serverInstance.timeout(request2, seconds);
       },
       writable: true,
       configurable: true
     },
     requestIP: {
-      value(request) {
+      value(request2) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot get request IP");
         }
-        return this.serverInstance.requestIP(request);
+        return this.serverInstance.requestIP(request2);
       },
       writable: true,
       configurable: true
@@ -8287,7 +10036,7 @@ function registerWebSocketHandling(RouterClass) {
   });
 }
 // src/response/macros.ts
-import process3 from "process";
+import process4 from "process";
 
 class ResponseMacroRegistry {
   macros = new Map;
@@ -8468,16 +10217,16 @@ var BuiltInResponseMacros = {
       }
     });
   },
-  redirect: (url, status = 302) => {
+  redirect: (url2, status = 302) => {
     return new Response(null, {
       status,
       headers: {
-        Location: url
+        Location: url2
       }
     });
   },
-  permanentRedirect: (url) => {
-    return BuiltInResponseMacros.redirect(url, 301);
+  permanentRedirect: (url2) => {
+    return BuiltInResponseMacros.redirect(url2, 301);
   },
   download: (data, filename, contentType = "application/octet-stream") => {
     return new Response(data, {
@@ -8548,7 +10297,7 @@ var BuiltInResponseMacros = {
       status,
       timestamp: new Date().toISOString(),
       checks,
-      uptime: process3.uptime?.() || 0
+      uptime: process4.uptime?.() || 0
     };
     return new Response(JSON.stringify(response2), {
       status: statusCode,
@@ -8612,8 +10361,8 @@ var BuiltInRules = {
     name: "url",
     validate: (value) => {
       try {
-        const url = new URL(value);
-        return Boolean(url);
+        const url2 = new URL(value);
+        return Boolean(url2);
       } catch {
         return false;
       }
@@ -9272,6 +11021,119 @@ 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";
 
@@ -9490,8 +11352,8 @@ function createCookieAccessor2(cookies) {
 
 class AuthTester {
   request;
-  constructor(request) {
-    this.request = request || createMockRequest();
+  constructor(request2) {
+    this.request = request2 || createMockRequest();
   }
   as(user) {
     this.request.user = user;
@@ -9719,16 +11581,16 @@ var authMocks = {
   })
 };
 var authHelpers = {
-  authenticatedRequest: (user, request) => {
-    return new AuthTester(request).as(user).getRequest();
+  authenticatedRequest: (user, request2) => {
+    return new AuthTester(request2).as(user).getRequest();
   },
-  jwtRequest: (payload = {}, request) => {
+  jwtRequest: (payload = {}, request2) => {
     const jwt = new JWTTester;
     const token = jwt.generateToken(payload);
-    return new AuthTester(request).withJWT(token).getRequest();
+    return new AuthTester(request2).withJWT(token).getRequest();
   },
-  sessionRequest: (sessionData = {}, request) => {
-    return new AuthTester(request).withSession(sessionData).getRequest();
+  sessionRequest: (sessionData = {}, request2) => {
+    return new AuthTester(request2).withSession(sessionData).getRequest();
   },
   verifyJWTStructure: (token) => {
     const parts = token.split(".");
@@ -9743,8 +11605,8 @@ var authHelpers = {
     }
   }
 };
-function createAuthTester(request) {
-  return new AuthTester(request);
+function createAuthTester(request2) {
+  return new AuthTester(request2);
 }
 function createJWTTester(options) {
   return new JWTTester(options);
@@ -9752,14 +11614,13 @@ 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(request) {
-    this.request = request || createMockRequest();
+  constructor(request2) {
+    this.request = request2 || createMockRequest();
     this.files = [];
   }
   addFile(testFile) {
@@ -9991,8 +11852,8 @@ var fileUploadScenarios = {
   }
 };
 var fileUploadAssertions = {
-  hasFiles: (request, count) => {
-    const files = request.files || [];
+  hasFiles: (request2, count) => {
+    const files = request2.files || [];
     if (count !== undefined && files.length !== count) {
       throw new Error(`Expected ${count} files, but got ${files.length}`);
     }
@@ -10000,8 +11861,8 @@ var fileUploadAssertions = {
       throw new Error("Expected request to have files");
     }
   },
-  hasFileWithField: (request, fieldName) => {
-    const files = request.files || [];
+  hasFileWithField: (request2, fieldName) => {
+    const files = request2.files || [];
     const hasField = files.some((file) => file.fieldName === fieldName);
     if (!hasField) {
       throw new Error(`Expected file with field name '${fieldName}'`);
@@ -10025,8 +11886,8 @@ var fileUploadAssertions = {
     }
   }
 };
-function createFileUploadTester(request) {
-  return new FileUploadTester(request);
+function createFileUploadTester(request2) {
+  return new FileUploadTester(request2);
 }
 var testFiles = {
   image: (fieldName = "image", filename = "test.jpg") => ({
@@ -10060,7 +11921,6 @@ var testFiles = {
     mimetype: "application/x-executable"
   })
 };
-
 // src/testing/middleware-testing.ts
 import { mock as mock3, spyOn } from "bun:test";
 class MiddlewareTester {
@@ -10071,15 +11931,15 @@ class MiddlewareTester {
     this.context = this.createContext();
   }
   createContext() {
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     const next = mock3(() => Promise.resolve(new Response("Next called", { status: 200 })));
     return {
-      request,
+      request: request2,
       next
     };
   }
-  withRequest(request) {
-    this.context.request = request;
+  withRequest(request2) {
+    this.context.request = request2;
     return this;
   }
   withNext(nextFn) {
@@ -10177,8 +12037,8 @@ class MiddlewareChainTester {
     this.request = createMockRequest();
     this.finalHandler = mock3(async () => new Response("Final handler", { status: 200 }));
   }
-  withRequest(request) {
-    this.request = request;
+  withRequest(request2) {
+    this.request = request2;
     return this;
   }
   withFinalHandler(handler) {
@@ -10218,11 +12078,11 @@ function createMiddlewareSpy() {
 }
 async function benchmarkMiddleware(middleware2, iterations = 1000) {
   const times = [];
-  const request = createMockRequest();
+  const request2 = createMockRequest();
   const next = mock3(async () => new Response("OK"));
   for (let i = 0;i < iterations; i++) {
     const start = performance.now();
-    await middleware2(request, next);
+    await middleware2(request2, next);
     const end = performance.now();
     times.push(end - start);
   }
@@ -10237,7 +12097,6 @@ async function benchmarkMiddleware(middleware2, iterations = 1000) {
     totalTime
   };
 }
-
 // src/testing/model-binding-testing.ts
 import { mock as mock4 } from "bun:test";
 class GenericMockModel {
@@ -10321,8 +12180,8 @@ class ModelBindingTester {
     this.options = options;
     this.request = createMockRequest();
   }
-  withRequest(request) {
-    this.request = request;
+  withRequest(request2) {
+    this.request = request2;
     return this;
   }
   withParams(params) {
@@ -10460,18 +12319,18 @@ var modelMocks = {
 };
 var constraintHelpers = {
   belongsTo: (userIdField = "userId") => {
-    const fn = async (model, request) => {
-      if (!request.user)
+    const fn = async (model, request2) => {
+      if (!request2.user)
         return false;
-      return model[userIdField] === request.user.id;
+      return model[userIdField] === request2.user.id;
     };
     return mock4(fn);
   },
   belongsToUser: () => {
-    const fn = async (model, request) => {
-      if (!request.user)
+    const fn = async (model, request2) => {
+      if (!request2.user)
         return false;
-      return model.userId === request.user.id;
+      return model.userId === request2.user.id;
     };
     return mock4(fn);
   },
@@ -10491,9 +12350,9 @@ var constraintHelpers = {
     return mock4(constraintFn);
   },
   combine: (...constraints) => {
-    const fn = async (model, request) => {
+    const fn = async (model, request2) => {
       for (const constraint of constraints) {
-        if (!await constraint(model, request)) {
+        if (!await constraint(model, request2)) {
           return false;
         }
       }
@@ -10550,24 +12409,24 @@ class ModelResolverTester {
 }
 var routeModelHelpers = {
   testRoute: async (path, params, modelBindings) => {
-    const request = createMockRequest("GET", path);
-    request.params = params;
+    const request2 = createMockRequest("GET", path);
+    request2.params = params;
     for (const [key, model] of Object.entries(modelBindings)) {
-      request.context = request.context || {};
-      request.context[key] = model;
+      request2.context = request2.context || {};
+      request2.context[key] = model;
     }
-    return request;
+    return request2;
   },
   createHandler: (expectedModels) => {
-    const fn = async (request) => {
-      const context = request.context || {};
+    const fn = async (request2) => {
+      const context = request2.context || {};
       for (const modelKey of expectedModels) {
         if (!context[modelKey]) {
           return new Response(`Model ${modelKey} not found`, { status: 404 });
         }
       }
       return new Response(JSON.stringify({
-        params: request.params,
+        params: request2.params,
         models: Object.fromEntries(expectedModels.map((key) => [key, context[key]]))
       }), {
         headers: { "Content-Type": "application/json" }
@@ -10576,16 +12435,16 @@ var routeModelHelpers = {
     return mock4(fn);
   },
   testBindingMiddleware: (bindings) => {
-    const fn = async (request, next) => {
-      request.context = request.context || {};
+    const fn = async (request2, next) => {
+      request2.context = request2.context || {};
       for (const [key, resolver] of Object.entries(bindings)) {
-        const paramValue = request.params[key];
+        const paramValue = request2.params[key];
         if (paramValue) {
           try {
             if (typeof resolver === "function") {
-              request.context[key] = await resolver(paramValue);
+              request2.context[key] = await resolver(paramValue);
             } else {
-              request.context[key] = resolver;
+              request2.context[key] = resolver;
             }
           } catch (error) {
             console.error(`Error resolving model ${key}:`, error);
@@ -10620,10 +12479,9 @@ var scopedBindingHelpers = {
     return requiredPermissions.every((permission) => user.permissions.includes(permission));
   }
 };
-
 // src/testing/performance-testing.ts
 import { mock as mock5 } from "bun:test";
-import process4 from "process";
+import process5 from "process";
 class PerformanceTester {
   metrics = [];
   startTime = 0;
@@ -10742,10 +12600,10 @@ class LoadTester {
 var benchmarkTests = {
   routeHandler: async (handler, iterations = 1000) => {
     const times = [];
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await handler(request);
+      await handler(request2);
       const end = performance.now();
       times.push(end - start);
     }
@@ -10764,11 +12622,11 @@ var benchmarkTests = {
   },
   middleware: async (middleware2, iterations = 1000) => {
     const times = [];
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     const next = mock5(async () => new Response("OK"));
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await middleware2(request, next);
+      await middleware2(request2, next);
       const end = performance.now();
       times.push(end - start);
     }
@@ -10841,11 +12699,11 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const initialHeap = process4.memoryUsage().heapUsed;
+    const initialHeap = process5.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
       const result = await fn();
       results.push(result);
-      const memUsage = process4.memoryUsage();
+      const memUsage = process5.memoryUsage();
       heapUsages.push(memUsage.heapUsed);
       if (i % 10 === 0 && globalThis.gc) {
         globalThis.gc();
@@ -10854,7 +12712,7 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const finalHeap = process4.memoryUsage().heapUsed;
+    const finalHeap = process5.memoryUsage().heapUsed;
     const averageHeapUsed = heapUsages.reduce((sum, usage) => sum + usage, 0) / heapUsages.length;
     const maxHeapUsed = Math.max(...heapUsages);
     const memoryLeakDetected = finalHeap - initialHeap > 1024 * 1024;
@@ -10868,17 +12726,17 @@ var memoryTests = {
   testRouteHandlerMemoryLeaks: async (handler, iterations = 1000) => {
     if (globalThis.gc)
       globalThis.gc();
-    const initialMemory = process4.memoryUsage().heapUsed;
+    const initialMemory = process5.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
-      const request = createMockRequest();
-      await handler(request);
+      const request2 = createMockRequest();
+      await handler(request2);
       if (i % 100 === 0 && globalThis.gc) {
         globalThis.gc();
       }
     }
     if (globalThis.gc)
       globalThis.gc();
-    const finalMemory = process4.memoryUsage().heapUsed;
+    const finalMemory = process5.memoryUsage().heapUsed;
     const memoryGrowth = finalMemory - initialMemory;
     const memoryLeakDetected = memoryGrowth > 5 * 1024 * 1024;
     return {
@@ -10970,7 +12828,7 @@ function createLoadTester(client, config2) {
 }
 var performanceUtils = {
   getCurrentMemoryUsage: () => {
-    const usage = process4.memoryUsage();
+    const usage = process5.memoryUsage();
     return {
       heapUsed: usage.heapUsed,
       heapTotal: usage.heapTotal,
@@ -10979,7 +12837,7 @@ var performanceUtils = {
     };
   },
   getCPUUsage: () => {
-    const usage = process4.cpuUsage();
+    const usage = process5.cpuUsage();
     return {
       user: usage.user,
       system: usage.system
@@ -10994,7 +12852,6 @@ var performanceUtils = {
     return JSON.stringify(results, null, 2);
   }
 };
-
 // src/testing/test-response.ts
 class TestResponseWrapper {
   status;
@@ -11115,14 +12972,14 @@ class TestResponseWrapper {
     }
     return this;
   }
-  expectRedirect(url) {
+  expectRedirect(url2) {
     if (this.status < 300 || this.status >= 400) {
       throw new Error(`Expected redirect status (3xx), got ${this.status}`);
     }
-    if (url) {
+    if (url2) {
       const location = this.headers.location;
-      if (location !== url) {
-        throw new Error(`Expected redirect to '${url}', got '${location}'`);
+      if (location !== url2) {
+        throw new Error(`Expected redirect to '${url2}', got '${location}'`);
       }
     }
     return this;
@@ -11265,24 +13122,24 @@ class TestClient {
   async request(method, path, options = {}) {
     const headers = { ...this.defaultHeaders, ...options.headers };
     const requestOptions = { ...options, headers };
-    const request = new TestRequestBuilder(method, path, requestOptions).build();
+    const request2 = new TestRequestBuilder(method, path, requestOptions).build();
     try {
-      const response2 = await this.handleRequest(request);
+      const response2 = await this.handleRequest(request2);
       return await createTestResponse(response2);
     } catch (error) {
       throw new Error(`Test request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  async handleRequest(request) {
-    const url = new URL(request.url);
-    const matchResult = this.findMatchingRoute(request.method, url.pathname);
+  async handleRequest(request2) {
+    const url2 = new URL(request2.url);
+    const matchResult = this.findMatchingRoute(request2.method, url2.pathname);
     if (!matchResult) {
       return new Response("Not Found", { status: 404 });
     }
     const { route, params } = matchResult;
-    request.params = { ...request.params, ...params };
+    request2.params = { ...request2.params, ...params };
     try {
-      const response2 = await this.executeMiddlewareChain(request, route);
+      const response2 = await this.executeMiddlewareChain(request2, 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" }), {
@@ -11322,28 +13179,28 @@ class TestClient {
     }
     return params;
   }
-  async executeMiddlewareChain(request, route) {
+  async executeMiddlewareChain(request2, 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(request, next);
+        return await middleware2(request2, next);
       } else {
-        return await this.executeHandler(route.handler, request);
+        return await this.executeHandler(route.handler, request2);
       }
     };
     const result = await next();
     return result || new Response("No response", { status: 500 });
   }
-  async executeHandler(handler, request) {
+  async executeHandler(handler, request2) {
     if (typeof handler === "function") {
-      return await handler(request);
+      return await handler(request2);
     } 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(request);
+      return await instance.handle(request2);
     }
     throw new Error("Invalid handler type");
   }
@@ -11384,7 +13241,6 @@ 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";
 
@@ -11739,13 +13595,13 @@ export {
   spyOnMiddleware,
   singleFileUpload,
   signRequest,
-  setCurrentRequest2 as setCurrentRequest,
+  setCurrentRequest,
   setContainer,
   session,
   securitySuite,
   security,
   scopedBindingHelpers,
-  runWithRequest2 as runWithRequest,
+  runWithRequest,
   rule,
   router,
   routeModelHelpers,
@@ -11758,7 +13614,7 @@ export {
   requestSigning,
   requestId,
   request,
-  registerNamedRoute2 as registerNamedRoute,
+  registerNamedRoute,
   rateLimitRegistry,
   rateLimit,
   processHtmlTemplate,
@@ -11788,7 +13644,7 @@ export {
   globalValidator,
   globalMiddlewarePipeline,
   getNamedRoutes,
-  getNamedRoutePath2 as getNamedRoutePath,
+  getNamedRoutePath,
   getCurrentRequest,
   getContainer,
   getConfig,
@@ -11919,7 +13775,7 @@ export {
   FileUpload,
   FileSessionStore,
   FileSecurity,
-  Errors,
+  exports_errors as Errors,
   EnvironmentManager,
   EnhancementPresets,
   DomainMatcher,
@@ -11939,6 +13795,6 @@ export {
   BuiltInRules,
   BindingBuilder,
   AuthTester,
-  default2 as Auth,
+  auth_default as Auth,
   ApiKeyManager
 };