@stacksjs/bun-router 0.0.15 → 0.0.17

package/dist/index.js

@@ -26,8 +26,6 @@ import {
   Session,
   SessionManager,
   SignatureError,
-  __export,
-  __require,
   apiKeyAuth,
   auth,
   basicAuth,
@@ -66,9 +64,50 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-j0e7z7hd.js";
+} from "./chunk-cgptvjdf.js";
+import {
+  AuthenticationException,
+  AuthorizationException,
+  BindingBuilder,
+  BusinessLogicException,
+  CircuitBreakerOpenException,
+  CircularDependencyException,
+  ConfigurationException,
+  Container,
+  ContextualContainer,
+  DatabaseException,
+  DefaultServiceProviderManager,
+  EnvironmentManager,
+  ErrorFactory,
+  ExternalServiceException,
+  FileSystemException,
+  HandlerResolutionException,
+  InternalServerException,
+  MethodNotAllowedException,
+  MiddlewareConfigurationException,
+  ModelBindingException,
+  NotFoundException,
+  RateLimitException,
+  RouteConflictException,
+  RouteNotFoundException,
+  RouterErrorFactory,
+  RouterException,
+  ServiceUnavailableException,
+  TimeoutException,
+  ValidationException,
+  createContainer,
+  detectRouteConflicts,
+  findSimilarRoutes,
+  getContainer,
+  setContainer
+} from "./chunk-g3ybefhg.js";
+import {
+  __export,
+  __require
+} from "./chunk-1ahs68ys.js";
 
 // src/auth.ts
+import { timingSafeEqual } from "crypto";
 function base64UrlEncode(str) {
   return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
@@ -132,7 +171,9 @@ class JWT {
       }
       const data = `${encodedHeader}.${encodedPayload}`;
       const expectedSignature = this.createSignature(data, this.secret, header.alg);
-      if (signature !== expectedSignature) {
+      const sigBuf = Buffer.from(signature);
+      const expectedBuf = Buffer.from(expectedSignature);
+      if (sigBuf.length !== expectedBuf.length || !timingSafeEqual(sigBuf, expectedBuf)) {
         throw new Error("Invalid signature");
       }
       const now = Math.floor(Date.now() / 1000);
@@ -386,381 +427,6 @@ __export(exports_errors, {
   AuthenticationException: () => AuthenticationException
 });
 
-// src/errors/exceptions.ts
-class RouterException extends Error {
-  code;
-  statusCode;
-  context;
-  retryable;
-  severity;
-  category;
-  timestamp;
-  cause;
-  constructor(details) {
-    super(details.message);
-    this.name = this.constructor.name;
-    this.code = details.code;
-    this.statusCode = details.statusCode || 500;
-    this.context = details.context || {};
-    this.retryable = details.retryable || false;
-    this.severity = details.severity || "medium";
-    this.category = details.category || "system";
-    this.timestamp = new Date;
-    this.cause = details.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      context: this.context,
-      retryable: this.retryable,
-      severity: this.severity,
-      category: this.category,
-      timestamp: this.timestamp.toISOString(),
-      stack: this.stack,
-      cause: this.cause ? {
-        name: this.cause.name,
-        message: this.cause.message,
-        stack: this.cause.stack
-      } : undefined
-    };
-  }
-  toResponse() {
-    const body = {
-      error: {
-        code: this.code,
-        message: this.message,
-        statusCode: this.statusCode,
-        timestamp: this.timestamp.toISOString(),
-        requestId: this.context.requestId
-      }
-    };
-    return new Response(JSON.stringify(body), {
-      status: this.statusCode,
-      headers: {
-        "Content-Type": "application/json",
-        "X-Error-Code": this.code,
-        "X-Request-ID": this.context.requestId || ""
-      }
-    });
-  }
-}
-
-class ValidationException extends RouterException {
-  fields;
-  constructor(message, fields = {}, context) {
-    super({
-      code: "VALIDATION_ERROR",
-      message,
-      statusCode: 400,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "validation"
-    });
-    this.fields = fields;
-  }
-  toResponse() {
-    const body = {
-      error: {
-        code: this.code,
-        message: this.message,
-        statusCode: this.statusCode,
-        timestamp: this.timestamp.toISOString(),
-        requestId: this.context.requestId,
-        fields: this.fields
-      }
-    };
-    return new Response(JSON.stringify(body), {
-      status: this.statusCode,
-      headers: {
-        "Content-Type": "application/json",
-        "X-Error-Code": this.code,
-        "X-Request-ID": this.context.requestId || ""
-      }
-    });
-  }
-}
-
-class AuthenticationException extends RouterException {
-  constructor(message = "Authentication required", context) {
-    super({
-      code: "AUTHENTICATION_ERROR",
-      message,
-      statusCode: 401,
-      context,
-      retryable: false,
-      severity: "medium",
-      category: "authentication"
-    });
-  }
-}
-
-class AuthorizationException extends RouterException {
-  requiredPermissions;
-  constructor(message = "Access denied", requiredPermissions, context) {
-    super({
-      code: "AUTHORIZATION_ERROR",
-      message,
-      statusCode: 403,
-      context,
-      retryable: false,
-      severity: "medium",
-      category: "authorization"
-    });
-    this.requiredPermissions = requiredPermissions;
-  }
-}
-
-class NotFoundException extends RouterException {
-  resource;
-  resourceId;
-  constructor(message = "Resource not found", resource, resourceId, context) {
-    super({
-      code: "NOT_FOUND",
-      message,
-      statusCode: 404,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "business"
-    });
-    this.resource = resource;
-    this.resourceId = resourceId;
-  }
-}
-
-class MethodNotAllowedException extends RouterException {
-  allowedMethods;
-  constructor(method, allowedMethods, context) {
-    super({
-      code: "METHOD_NOT_ALLOWED",
-      message: `Method ${method} not allowed. Allowed methods: ${allowedMethods.join(", ")}`,
-      statusCode: 405,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "business"
-    });
-    this.allowedMethods = allowedMethods;
-  }
-  toResponse() {
-    const response = super.toResponse();
-    response.headers.set("Allow", this.allowedMethods.join(", "));
-    return response;
-  }
-}
-
-class TimeoutException extends RouterException {
-  timeoutMs;
-  constructor(message = "Request timeout", timeoutMs, context) {
-    super({
-      code: "REQUEST_TIMEOUT",
-      message,
-      statusCode: 408,
-      context,
-      retryable: true,
-      severity: "medium",
-      category: "network"
-    });
-    this.timeoutMs = timeoutMs;
-  }
-}
-
-class RateLimitException extends RouterException {
-  retryAfter;
-  limit;
-  remaining;
-  constructor(message = "Rate limit exceeded", retryAfter, limit, remaining = 0, context) {
-    super({
-      code: "RATE_LIMIT_EXCEEDED",
-      message,
-      statusCode: 429,
-      context,
-      retryable: true,
-      severity: "medium",
-      category: "network"
-    });
-    this.retryAfter = retryAfter;
-    this.limit = limit;
-    this.remaining = remaining;
-  }
-  toResponse() {
-    const response = super.toResponse();
-    response.headers.set("Retry-After", this.retryAfter.toString());
-    response.headers.set("X-RateLimit-Limit", this.limit.toString());
-    response.headers.set("X-RateLimit-Remaining", this.remaining.toString());
-    return response;
-  }
-}
-
-class InternalServerException extends RouterException {
-  constructor(message = "Internal server error", cause, context) {
-    super({
-      code: "INTERNAL_SERVER_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      cause,
-      retryable: true,
-      severity: "high",
-      category: "system"
-    });
-  }
-}
-
-class ServiceUnavailableException extends RouterException {
-  retryAfter;
-  constructor(message = "Service unavailable", retryAfter, context) {
-    super({
-      code: "SERVICE_UNAVAILABLE",
-      message,
-      statusCode: 503,
-      context,
-      retryable: true,
-      severity: "high",
-      category: "system"
-    });
-    this.retryAfter = retryAfter;
-  }
-  toResponse() {
-    const response = super.toResponse();
-    if (this.retryAfter) {
-      response.headers.set("Retry-After", this.retryAfter.toString());
-    }
-    return response;
-  }
-}
-
-class DatabaseException extends RouterException {
-  query;
-  operation;
-  constructor(message, operation, query, cause, context) {
-    super({
-      code: "DATABASE_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      cause,
-      retryable: true,
-      severity: "high",
-      category: "database"
-    });
-    this.operation = operation;
-    this.query = query;
-  }
-}
-
-class ExternalServiceException extends RouterException {
-  service;
-  endpoint;
-  constructor(message, service, endpoint, statusCode = 502, cause, context) {
-    super({
-      code: "EXTERNAL_SERVICE_ERROR",
-      message,
-      statusCode,
-      context,
-      cause,
-      retryable: true,
-      severity: "medium",
-      category: "external"
-    });
-    this.service = service;
-    this.endpoint = endpoint;
-  }
-}
-
-class CircuitBreakerOpenException extends RouterException {
-  service;
-  nextAttemptAt;
-  constructor(service, nextAttemptAt, context) {
-    super({
-      code: "CIRCUIT_BREAKER_OPEN",
-      message: `Circuit breaker is open for service: ${service}. Next attempt at: ${nextAttemptAt.toISOString()}`,
-      statusCode: 503,
-      context,
-      retryable: true,
-      severity: "medium",
-      category: "external"
-    });
-    this.service = service;
-    this.nextAttemptAt = nextAttemptAt;
-  }
-}
-
-class BusinessLogicException extends RouterException {
-  businessRule;
-  constructor(message, businessRule, context) {
-    super({
-      code: "BUSINESS_LOGIC_ERROR",
-      message,
-      statusCode: 422,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "business"
-    });
-    this.businessRule = businessRule;
-  }
-}
-
-class ConfigurationException extends RouterException {
-  configKey;
-  constructor(message, configKey, context) {
-    super({
-      code: "CONFIGURATION_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "critical",
-      category: "system"
-    });
-    this.configKey = configKey;
-  }
-}
-
-class FileSystemException extends RouterException {
-  path;
-  operation;
-  constructor(message, path, operation, cause, context) {
-    super({
-      code: "FILESYSTEM_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      cause,
-      retryable: false,
-      severity: "medium",
-      category: "system"
-    });
-    this.path = path;
-    this.operation = operation;
-  }
-}
-var ErrorFactory = {
-  validation: (message, fields, context) => new ValidationException(message, fields, context),
-  authentication: (message, context) => new AuthenticationException(message, context),
-  authorization: (message, requiredPermissions, context) => new AuthorizationException(message, requiredPermissions, context),
-  notFound: (resource, resourceId, context) => new NotFoundException(undefined, resource, resourceId, context),
-  methodNotAllowed: (method, allowedMethods, context) => new MethodNotAllowedException(method, allowedMethods, context),
-  timeout: (timeoutMs, message, context) => new TimeoutException(message, timeoutMs, context),
-  rateLimit: (retryAfter, limit, remaining, context) => new RateLimitException(undefined, retryAfter, limit, remaining, context),
-  internalServer: (message, cause, context) => new InternalServerException(message, cause, context),
-  serviceUnavailable: (message, retryAfter, context) => new ServiceUnavailableException(message, retryAfter, context),
-  database: (message, operation, query, cause, context) => new DatabaseException(message, operation, query, cause, context),
-  externalService: (message, service, endpoint, statusCode, cause, context) => new ExternalServiceException(message, service, endpoint, statusCode, cause, context),
-  circuitBreakerOpen: (service, nextAttemptAt, context) => new CircuitBreakerOpenException(service, nextAttemptAt, context),
-  businessLogic: (message, businessRule, context) => new BusinessLogicException(message, businessRule, context),
-  configuration: (message, configKey, context) => new ConfigurationException(message, configKey, context),
-  fileSystem: (message, path, operation, cause, context) => new FileSystemException(message, path, operation, cause, context)
-};
-
 // src/errors/circuit-breaker.ts
 class CircuitBreaker {
   config;
@@ -794,7 +460,7 @@ class CircuitBreaker {
       consecutiveFailures: 0,
       consecutiveSuccesses: 0
     };
-    setInterval(() => this.cleanupOldRequests(), this.config.monitoringPeriod / 4);
+    setInterval(() => this.cleanupOldRequests(), this.config.monitoringPeriod / 4).unref?.();
   }
   async execute(call) {
     if (this.state === "OPEN") {
@@ -1705,6 +1371,7 @@ class ServiceHealthMonitor {
         consecutiveFailures: 0
       });
       const interval = setInterval(() => this.performHealthCheck(serviceName, healthConfig), healthConfig.interval);
+      interval.unref?.();
       this.healthCheckIntervals.set(serviceName, interval);
     }
   }
@@ -2334,448 +2001,44 @@ function createAdvancedErrorHandler(config2 = {}) {
     cleanup: () => handler.cleanup()
   };
 }
-// src/errors/router-errors.ts
-class RouteConflictException extends RouterException {
-  conflictingRoutes;
-  suggestion;
-  constructor(conflictingRoutes, context) {
-    const message = RouteConflictException.buildMessage(conflictingRoutes);
-    const suggestion = RouteConflictException.buildSuggestion(conflictingRoutes);
-    super({
-      code: "ROUTE_CONFLICT",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "critical",
-      category: "system"
-    });
-    this.conflictingRoutes = conflictingRoutes;
-    this.suggestion = suggestion;
-  }
-  static buildMessage(routes) {
-    const lines = [
-      "Route conflict detected! Multiple routes match the same path pattern.",
-      "",
-      "Conflicting routes:"
-    ];
-    for (const route of routes) {
-      lines.push(`  \u2022 ${route.method} ${route.path}`);
-      if (route.name) {
-        lines.push(`    Name: "${route.name}"`);
-      }
-      if (route.definedAt) {
-        lines.push(`    Defined at: ${route.definedAt}`);
-      }
-    }
-    return lines.join(`
-`);
-  }
-  static buildSuggestion(routes) {
-    const suggestions = [];
-    const hasStatic = routes.some((r) => !r.path.includes("{"));
-    const hasDynamic = routes.some((r) => r.path.includes("{"));
-    if (hasStatic && hasDynamic) {
-      suggestions.push("\u2022 Static routes should be defined before dynamic routes", "\u2022 Consider using route constraints (whereNumber, whereUuid) to differentiate");
-    }
-    const dynamicRoutes = routes.filter((r) => r.path.includes("{"));
-    if (dynamicRoutes.length > 1) {
-      suggestions.push("\u2022 Use different parameter names or add constraints:", '  router.get("/users/{id}").whereNumber("id")', '  router.get("/users/{slug}").whereAlpha("slug")');
-    }
-    const hasWildcard = routes.some((r) => r.path.includes("*"));
-    if (hasWildcard) {
-      suggestions.push("\u2022 Wildcard routes should be defined last", "\u2022 Consider using more specific path prefixes");
-    }
-    if (suggestions.length === 0) {
-      suggestions.push("\u2022 Rename one of the conflicting routes", "\u2022 Use route groups with different prefixes", "\u2022 Add parameter constraints to differentiate routes");
-    }
-    return `How to fix:
-${suggestions.join(`
-`)}`;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      conflictingRoutes: this.conflictingRoutes,
-      suggestion: this.suggestion
-    };
-  }
-}
-
-class CircularDependencyException extends RouterException {
-  dependencyChain;
-  suggestion;
-  constructor(dependencyChain, context) {
-    const message = CircularDependencyException.buildMessage(dependencyChain);
-    const suggestion = CircularDependencyException.buildSuggestion(dependencyChain);
-    super({
-      code: "CIRCULAR_DEPENDENCY",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "critical",
-      category: "system"
-    });
-    this.dependencyChain = dependencyChain;
-    this.suggestion = suggestion;
-  }
-  static buildMessage(chain) {
-    const lines = [
-      "Circular dependency detected in the dependency injection container!",
-      "",
-      "Dependency chain:",
-      ""
-    ];
-    for (let i = 0;i < chain.length; i++) {
-      const isLast = i === chain.length - 1;
-      const prefix = i === 0 ? "\u250C\u2500\u25BA" : isLast ? "\u2514\u2500\u25BA" : "\u251C\u2500\u25BA";
-      lines.push(`  ${prefix} ${chain[i]}`);
-      if (!isLast) {
-        lines.push("  \u2502");
-      }
-    }
-    lines.push("  \u2502");
-    lines.push(`  \u2514\u2500\u2500 cycles back to: ${chain[0]}`);
-    return lines.join(`
-`);
-  }
-  static buildSuggestion(chain) {
-    return `How to fix:
-
-1. Break the cycle by introducing an interface:
-  \u2022 Create an interface for one of the dependencies
-  \u2022 Use lazy injection: container.bind('${chain[0]}').lazy()
-
-2. Restructure your dependencies:
-  \u2022 Extract shared logic into a separate service
-  \u2022 Use events/callbacks instead of direct dependencies
-
-3. Use setter injection instead of constructor injection:
-  \u2022 Remove the dependency from the constructor
-  \u2022 Set it after instantiation using a setter method
-
-4. Check if the dependency is actually needed:
-  \u2022 Sometimes circular dependencies indicate a design issue
-  \u2022 Consider if the classes have too many responsibilities
-
-Dependency chain involved:
-${chain.map((dep, i) => `  ${i + 1}. ${dep}`).join(`
-`)}`;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      dependencyChain: this.dependencyChain,
-      suggestion: this.suggestion
-    };
-  }
-}
-
-class MiddlewareConfigurationException extends RouterException {
-  middlewareName;
-  configErrors;
-  suggestion;
-  constructor(middlewareName, configErrors, context) {
-    const message = `Middleware "${middlewareName}" configuration error:
-${configErrors.map((e) => `  \u2022 ${e}`).join(`
-`)}`;
-    super({
-      code: "MIDDLEWARE_CONFIGURATION_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "high",
-      category: "system"
-    });
-    this.middlewareName = middlewareName;
-    this.configErrors = configErrors;
-    this.suggestion = this.buildSuggestion();
-  }
-  buildSuggestion() {
-    return `How to fix:
-\u2022 Check the middleware documentation for required options
-\u2022 Ensure all required configuration values are provided
-\u2022 Verify configuration value types match expected types
-
-Example configuration:
-  router.use(new ${this.middlewareName}({
-    // Add required options here
-  }))`;
-  }
-}
-
-class RouteNotFoundException extends RouterException {
-  requestedPath;
-  requestedMethod;
-  similarRoutes;
-  suggestion;
-  constructor(requestedMethod, requestedPath, similarRoutes = [], context) {
-    const message = RouteNotFoundException.buildMessage(requestedMethod, requestedPath, similarRoutes);
-    super({
-      code: "ROUTE_NOT_FOUND",
-      message,
-      statusCode: 404,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "business"
-    });
-    this.requestedPath = requestedPath;
-    this.requestedMethod = requestedMethod;
-    this.similarRoutes = similarRoutes;
-    this.suggestion = this.buildSuggestion();
-  }
-  static buildMessage(method, path, similarRoutes) {
-    const lines = [
-      `Route not found: ${method} ${path}`
-    ];
-    if (similarRoutes.length > 0) {
-      lines.push("");
-      lines.push("Did you mean one of these routes?");
-      for (const route of similarRoutes.slice(0, 5)) {
-        lines.push(`  \u2022 ${route.method} ${route.path}`);
-        if (route.similarity) {
-          lines.push(`    (${Math.round(route.similarity * 100)}% match)`);
-        }
-      }
-    }
-    return lines.join(`
-`);
-  }
-  buildSuggestion() {
-    const suggestions = [
-      `\u2022 Verify the HTTP method is correct (you used ${this.requestedMethod})`,
-      "\u2022 Check for typos in the URL path",
-      "\u2022 Ensure the route is registered before the server starts",
-      "\u2022 Check if the route requires specific middleware (e.g., auth)"
-    ];
-    if (this.requestedPath.includes("//")) {
-      suggestions.push("\u2022 Remove duplicate slashes from the URL");
-    }
-    if (!this.requestedPath.startsWith("/")) {
-      suggestions.push("\u2022 Ensure the path starts with a forward slash (/)");
-    }
-    return `How to fix:
-${suggestions.join(`
-`)}`;
-  }
-}
-
-class HandlerResolutionException extends RouterException {
-  handlerRef;
-  suggestion;
-  constructor(handlerRef, reason, context) {
-    const message = `Failed to resolve handler "${handlerRef}": ${reason}`;
-    super({
-      code: "HANDLER_RESOLUTION_ERROR",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "high",
-      category: "system"
-    });
-    this.handlerRef = handlerRef;
-    this.suggestion = this.buildSuggestion(handlerRef);
-  }
-  buildSuggestion(handlerRef) {
-    const isControllerMethod = handlerRef.includes("@");
-    const isActionPath = handlerRef.includes("/");
-    if (isControllerMethod) {
-      const [controller, method] = handlerRef.split("@");
-      return `How to fix:
-\u2022 Ensure the controller "${controller}" is registered in the container
-\u2022 Verify the method "${method}" exists and is public
-\u2022 Check the controller file is imported
-
-Example:
-  // Register the controller
-  container.singleton('${controller}', ${controller})
-
-  // Define the route
-  router.get('/path', '${handlerRef}')`;
-    }
-    if (isActionPath) {
-      return `How to fix:
-\u2022 Ensure the action class exists at the specified path
-\u2022 Verify the action has a "handle" method
-\u2022 Check the action file is properly exported
-
-Example:
-  // Action class at ${handlerRef}.ts
-  export default class ${handlerRef.split("/").pop()} {
-    handle(req: Request): Response {
-      return new Response('OK')
-    }
-  }`;
-    }
-    return `How to fix:
-\u2022 Verify the handler reference is correct
-\u2022 Ensure the handler function/class is exported
-\u2022 Check for circular dependencies in the handler module`;
-  }
-}
-
-class ModelBindingException extends RouterException {
-  modelName;
-  paramName;
-  paramValue;
-  suggestion;
-  constructor(modelName, paramName, paramValue, reason, context) {
-    const message = `Failed to bind model "${modelName}" for parameter "${paramName}" with value "${paramValue}": ${reason}`;
-    super({
-      code: "MODEL_BINDING_ERROR",
-      message,
-      statusCode: 404,
-      context,
-      retryable: false,
-      severity: "low",
-      category: "business"
-    });
-    this.modelName = modelName;
-    this.paramName = paramName;
-    this.paramValue = paramValue;
-    this.suggestion = this.buildSuggestion();
-  }
-  buildSuggestion() {
-    return `How to fix:
-\u2022 Verify the ${this.paramName} "${this.paramValue}" exists in your data source
-\u2022 Check if the model resolver is correctly configured
-\u2022 Ensure the route parameter matches the model's identifier field
-
-Example model binding:
-  router.model('${this.paramName}', async (value) => {
-    const ${this.modelName.toLowerCase()} = await db.${this.modelName.toLowerCase()}s.findUnique({
-      where: { id: value }
-    })
-    if (!${this.modelName.toLowerCase()}) {
-      throw new Error('${this.modelName} not found')
-    }
-    return ${this.modelName.toLowerCase()}
-  })`;
-  }
-}
-function findSimilarRoutes(requestedPath, availableRoutes, maxResults = 5) {
-  const results = [];
-  for (const route of availableRoutes) {
-    const similarity = calculateSimilarity(requestedPath, route.path);
-    if (similarity > 0.3) {
-      results.push({
-        method: route.method,
-        path: route.path,
-        similarity
-      });
-    }
-  }
-  return results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, maxResults);
-}
-function calculateSimilarity(str1, str2) {
-  const len1 = str1.length;
-  const len2 = str2.length;
-  if (len1 === 0)
-    return len2 === 0 ? 1 : 0;
-  if (len2 === 0)
-    return 0;
-  const matrix = [];
-  for (let i = 0;i <= len1; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0;j <= len2; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1;i <= len1; i++) {
-    for (let j = 1;j <= len2; j++) {
-      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-    }
-  }
-  const distance = matrix[len1][len2];
-  const maxLen = Math.max(len1, len2);
-  return 1 - distance / maxLen;
-}
-function detectRouteConflicts(routes) {
-  const conflicts = [];
-  const checked = new Set;
-  for (let i = 0;i < routes.length; i++) {
-    const route1 = routes[i];
-    const key1 = `${route1.method}:${route1.path}`;
-    if (checked.has(key1))
-      continue;
-    const conflicting = [];
-    for (let j = i + 1;j < routes.length; j++) {
-      const route2 = routes[j];
-      if (route1.method === route2.method && routesConflict(route1.path, route2.path)) {
-        if (conflicting.length === 0) {
-          conflicting.push({
-            method: route1.method,
-            path: route1.path,
-            name: route1.name
-          });
-        }
-        conflicting.push({
-          method: route2.method,
-          path: route2.path,
-          name: route2.name
-        });
-        checked.add(`${route2.method}:${route2.path}`);
-      }
-    }
-    if (conflicting.length > 0) {
-      conflicts.push(conflicting);
-    }
-    checked.add(key1);
-  }
-  return conflicts;
-}
-function routesConflict(path1, path2) {
-  if (path1 === path2)
-    return true;
-  const segments1 = path1.split("/").filter(Boolean);
-  const segments2 = path2.split("/").filter(Boolean);
-  if (segments1.length !== segments2.length) {
-    const hasWildcard1 = path1.includes("*");
-    const hasWildcard2 = path2.includes("*");
-    if (!hasWildcard1 && !hasWildcard2)
-      return false;
-  }
-  const maxLen = Math.max(segments1.length, segments2.length);
-  for (let i = 0;i < maxLen; i++) {
-    const seg1 = segments1[i] || "";
-    const seg2 = segments2[i] || "";
-    if (seg1 === "*" || seg2 === "*")
-      return true;
-    const isDynamic1 = seg1.startsWith("{") && seg1.endsWith("}");
-    const isDynamic2 = seg2.startsWith("{") && seg2.endsWith("}");
-    if (!isDynamic1 && !isDynamic2) {
-      if (seg1 !== seg2)
-        return false;
-    }
-  }
-  return true;
-}
-var RouterErrorFactory = {
-  routeConflict: (routes, context) => new RouteConflictException(routes, context),
-  circularDependency: (chain, context) => new CircularDependencyException(chain, context),
-  middlewareConfig: (name, errors, context) => new MiddlewareConfigurationException(name, errors, context),
-  routeNotFound: (method, path, similarRoutes, context) => new RouteNotFoundException(method, path, similarRoutes, context),
-  handlerResolution: (ref, reason, context) => new HandlerResolutionException(ref, reason, context),
-  modelBinding: (model, param, value, reason, context) => new ModelBindingException(model, param, value, reason, context)
-};
 // 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);
 }
 function setCurrentRequest(req) {
   const store = storage.getStore();
-  if (store)
+  if (store) {
     store.current = req;
+    return;
+  }
+  if (syncCurrent !== null) {
+    syncCurrent = req;
+  }
 }
 function getCurrentRequest() {
-  return storage.getStore()?.current ?? undefined;
+  if (!contextEnabled) {
+    contextEnabled = true;
+    return syncCurrent ?? undefined;
+  }
+  return storage.getStore()?.current ?? syncCurrent ?? undefined;
 }
 function request() {
   const req = getCurrentRequest();
@@ -3942,13 +3205,20 @@ function registerFileBasedRouting(RouterClass) {
           }
         }
         this._viewsDir = viewsDir;
+        const existingGetPaths = new Set;
+        for (const r of this.routes) {
+          if (r.method === "GET") {
+            existingGetPaths.add(r.path);
+          }
+        }
         for (const route of routes) {
-          const handler = createViewHandler(route.filePath, viewsDir, config2, this.config.queryPreservation);
-          const existingRoute = this.routes.find((r) => r.path === route.routePath && r.method === "GET");
-          if (!existingRoute) {
-            this.get(route.routePath, handler, "web");
-            this._fileBasedRoutes.push(route);
+          if (existingGetPaths.has(route.routePath)) {
+            continue;
           }
+          const handler = createViewHandler(route.filePath, viewsDir, config2, this.config.queryPreservation);
+          this.get(route.routePath, handler, "web");
+          this._fileBasedRoutes.push(route);
+          existingGetPaths.add(route.routePath);
         }
         this._fileRoutesInitialized = true;
       },
@@ -5696,7 +4966,11 @@ function url(name, params = {}, options = {}) {
       consumed.add(key);
     }
   }
-  resolved = resolved.replace(/\/\{[^}]+\?\}/g, "");
+  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(", ")}`);
@@ -5715,24 +4989,229 @@ function url(name, params = {}, options = {}) {
   return resolved;
 }
 
-// src/router/fluent-routing.ts
-class FluentRouteBuilder {
-  method;
-  path;
-  handler;
-  middleware = [];
-  cacheConfig;
-  throttleConfig;
-  routeName;
-  modelBindings = {};
-  constructor(method, path, handler) {
-    this.method = method;
-    this.path = path;
-    this.handler = handler;
+// src/utils.ts
+import { join as join3 } from "path";
+function normalizePath(path) {
+  let normalizedPath = path.replace(/\/+/g, "/");
+  if (!normalizedPath.startsWith("/")) {
+    normalizedPath = `/${normalizedPath}`;
   }
-  addMiddleware(middleware2) {
-    if (Array.isArray(middleware2)) {
-      this.middleware.push(...middleware2);
+  if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  return normalizedPath;
+}
+function toActionPath(path) {
+  return path.replace(/\//g, "_").toLowerCase();
+}
+function isActionClass(handler) {
+  if (typeof handler !== "function" && typeof handler !== "object") {
+    return false;
+  }
+  if (typeof handler === "function" && handler.prototype) {
+    const prototype = handler.prototype;
+    if (typeof prototype.handle === "function") {
+      return true;
+    }
+  }
+  if (typeof handler === "object" && handler !== null && "handle" in handler && typeof handler.handle === "function") {
+    return true;
+  }
+  return false;
+}
+function isRouteHandler(handler) {
+  return typeof handler === "function" && !isActionClass(handler);
+}
+function extractParamNames(pattern) {
+  const matches = pattern.match(/\{([^}]+)\}/g);
+  return matches ? matches.map((m) => m.slice(1, -1).replace("?", "")) : [];
+}
+function createPathRegex(pattern) {
+  const regexPattern = pattern.replace(/\{([^}]+)\}/g, "([^/]+)");
+  return new RegExp(`^${regexPattern}$`);
+}
+var PARAM_SEGMENT_RE = /\{([^}:]+)(?::[^}]+)?(\?)?\}/;
+var OPTIONAL_SEGMENT_RE = /\{[^}]+\?\}/;
+var compiledPatternCache = new Map;
+var constraintRegexCache = new Map;
+function compilePattern(pattern) {
+  const cached = compiledPatternCache.get(pattern);
+  if (cached)
+    return cached;
+  const isWildcard = pattern.endsWith("/*");
+  const normalizedPattern = normalizePath(pattern);
+  let optionalCount = 0;
+  const segments = normalizedPattern.split("/").filter(Boolean).map((seg) => {
+    const isOptional = OPTIONAL_SEGMENT_RE.test(seg);
+    if (isOptional)
+      optionalCount++;
+    const paramMatch = seg.match(PARAM_SEGMENT_RE);
+    return {
+      isParam: !!paramMatch,
+      paramName: paramMatch ? paramMatch[1].replace("?", "") : "",
+      isOptional,
+      literal: seg
+    };
+  });
+  const compiled = {
+    isWildcard,
+    wildcardBase: isWildcard ? pattern.slice(0, -2) : "",
+    segments,
+    optionalCount
+  };
+  compiledPatternCache.set(pattern, compiled);
+  return compiled;
+}
+function getConstraintRegex(constraint) {
+  const cached = constraintRegexCache.get(constraint);
+  if (cached !== undefined)
+    return cached;
+  let regex;
+  try {
+    regex = new RegExp(`^${constraint}$`);
+  } catch {
+    regex = null;
+  }
+  constraintRegexCache.set(constraint, regex);
+  return regex;
+}
+function matchPath(pattern, path, params, constraints) {
+  const compiled = compilePattern(pattern);
+  if (compiled.isWildcard && path.startsWith(compiled.wildcardBase)) {
+    return true;
+  }
+  const patternSegments = compiled.segments;
+  const pathSegments = normalizePath(path).split("/").filter(Boolean);
+  if (pathSegments.length < patternSegments.length - compiled.optionalCount || pathSegments.length > patternSegments.length) {
+    return false;
+  }
+  for (let i = 0;i < patternSegments.length; i++) {
+    const seg = patternSegments[i];
+    const pathSegment = pathSegments[i];
+    if (pathSegment === undefined) {
+      if (seg.isOptional) {
+        continue;
+      }
+      return false;
+    }
+    if (seg.isParam) {
+      params[seg.paramName] = pathSegment;
+      if (constraints && constraints[seg.paramName]) {
+        const regex = getConstraintRegex(constraints[seg.paramName]);
+        if (regex) {
+          if (!regex.test(pathSegment)) {
+            return false;
+          }
+        } else {
+          console.warn(`Invalid constraint regex for parameter ${seg.paramName}: ${constraints[seg.paramName]}`);
+        }
+      }
+    } else if (seg.literal !== pathSegment) {
+      return false;
+    }
+  }
+  return true;
+}
+function joinPaths(...segments) {
+  return normalizePath(segments.join("/"));
+}
+function validatePath(path) {
+  if (!path.startsWith("/")) {
+    return false;
+  }
+  const stack = [];
+  for (const char of path) {
+    if (char === "{") {
+      stack.push(char);
+    } else if (char === "}") {
+      if (stack.length === 0 || stack.pop() !== "{") {
+        return false;
+      }
+    }
+  }
+  return stack.length === 0;
+}
+async function fileExists(path) {
+  try {
+    const file = Bun.file(path);
+    return await file.exists();
+  } catch {
+    return false;
+  }
+}
+async function resolveViewPath(viewName, viewsPath, extensions) {
+  if (extensions.some((ext) => viewName.endsWith(ext))) {
+    const fullPath = normalizePath(join3(viewsPath, viewName));
+    if (await fileExists(fullPath)) {
+      return fullPath;
+    }
+    return null;
+  }
+  for (const ext of extensions) {
+    const fullPath = normalizePath(join3(viewsPath, `${viewName}${ext}`));
+    if (await fileExists(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function processHtmlTemplate(template, data) {
+  let result = template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const trimmedKey = key.trim();
+    const value = getNestedValue(data, trimmedKey);
+    return value !== undefined ? String(value) : match;
+  });
+  result = processConditionals(result, data);
+  result = processLoops(result, data);
+  return result;
+}
+function processConditionals(template, data) {
+  return template.replace(/\{\{#if ([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (_match, condition, content, alternative = "") => {
+    const conditionTrimmed = condition.trim();
+    const value = getNestedValue(data, conditionTrimmed);
+    return value ? content : alternative;
+  });
+}
+function processLoops(template, data) {
+  return template.replace(/\{\{#each ([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (_match, arrayKey, content) => {
+    const array = getNestedValue(data, arrayKey.trim());
+    if (!Array.isArray(array))
+      return "";
+    return array.map((item) => {
+      return content.replace(/\{\{@index\}\}/g, String(array.indexOf(item))).replace(/\{\{this\}\}/g, String(item)).replace(/\{\{this\.([^}]+)\}\}/g, (_matchStr, prop) => {
+        const value = item[prop.trim()];
+        return value !== undefined ? String(value) : "";
+      });
+    }).join("");
+  });
+}
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((prev, curr) => {
+    if (prev && typeof prev === "object" && curr in prev) {
+      return prev[curr];
+    }
+    return;
+  }, obj);
+}
+
+// src/router/fluent-routing.ts
+class FluentRouteBuilder {
+  method;
+  path;
+  handler;
+  middleware = [];
+  cacheConfig;
+  throttleConfig;
+  routeName;
+  modelBindings = {};
+  constructor(method, path, handler) {
+    this.method = method;
+    this.path = path;
+    this.handler = handler;
+  }
+  addMiddleware(middleware2) {
+    if (Array.isArray(middleware2)) {
+      this.middleware.push(...middleware2);
     } else {
       this.middleware.push(middleware2);
     }
@@ -5801,14 +5280,13 @@ class FluentConditionalBuilder {
   }
   middleware(middlewareName) {
     const [name, params] = middlewareName.split(":");
-    const middlewareFactory = this.router.namedMiddleware.get(name);
+    const middlewareFactory = this.router.resolveNamedMiddleware(name);
     if (!middlewareFactory) {
       throw new Error(`Unknown middleware: ${name}`);
     }
-    const middlewareHandler = middlewareFactory(params);
-    this.router.conditionalMiddleware.push({
+    this.router.addConditionalMiddleware({
       condition: this.condition,
-      middleware: [middlewareHandler]
+      middleware: [middlewareFactory(params)]
     });
     return this;
   }
@@ -5937,6 +5415,12 @@ class FluentRouter {
   when(condition) {
     return new FluentConditionalBuilder(this, condition);
   }
+  resolveNamedMiddleware(name) {
+    return this.namedMiddleware.get(name);
+  }
+  addConditionalMiddleware(conditional) {
+    this.conditionalMiddleware.push(conditional);
+  }
   middleware(middlewareName) {
     const [name, params] = middlewareName.split(":");
     const middlewareFactory = this.namedMiddleware.get(name);
@@ -6058,7 +5542,6 @@ class FluentRouter {
     return [...this.routes, ...this.subdomainRouter.getAllRoutes()];
   }
   async handle(request2) {
-    const _url = new URL(request2.url);
     const url2 = new URL(request2.url);
     const domain = url2.hostname;
     const match = this.subdomainRouter.findDomainGroup(domain);
@@ -6066,34 +5549,42 @@ class FluentRouter {
       const enhancedReq = request2;
       enhancedReq.domainParams = match.parameters;
       for (const route of match.group.getRoutes()) {
-        if (this.matchesRoute(route, request2)) {
-          return await this.executeRoute(route, enhancedReq);
+        const params = this.matchRouteParams(route, request2.method, url2.pathname);
+        if (params) {
+          return await this.executeRoute(route, enhancedReq, params);
         }
       }
     }
     for (const route of this.routes) {
-      if (this.matchesRoute(route, request2)) {
-        return await this.executeRoute(route, request2);
+      const params = this.matchRouteParams(route, request2.method, url2.pathname);
+      if (params) {
+        return await this.executeRoute(route, request2, params);
       }
     }
     return null;
   }
-  matchesRoute(route, request2) {
-    if (route.method !== request2.method) {
-      return false;
+  matchRouteParams(route, method, pathname) {
+    if (route.method !== method) {
+      return null;
     }
-    const url2 = new URL(request2.url);
-    const routePattern = route.path.replace(/\{([^:}]+):?([^}]*)\}/g, "([^/]+)");
-    const regex = new RegExp(`^${routePattern}$`);
-    return regex.test(url2.pathname);
+    const params = {};
+    return matchPath(route.path, pathname, params) ? params : null;
   }
-  async executeRoute(route, request2) {
-    const allMiddleware = [...this.globalMiddleware, ...route.middleware];
+  async executeRoute(route, request2, params) {
+    request2.params = params;
+    const allMiddleware = [...this.globalMiddleware];
+    for (const conditional of this.conditionalMiddleware) {
+      if (await conditional.condition(request2)) {
+        allMiddleware.push(...conditional.middleware);
+      }
+    }
+    allMiddleware.push(...route.middleware);
     let index = 0;
     const next = async () => {
       if (index < allMiddleware.length) {
         const middleware2 = allMiddleware[index++];
-        return await middleware2(request2, next);
+        const result = await middleware2(request2, next);
+        return result ?? new Response(null);
       }
       return await route.handler(request2);
     };
@@ -6133,9 +5624,16 @@ var RouteFactory = {
 };
 var RouterUtils = {
   route: (name, params = {}, query = {}) => {
-    let url2 = `/${name}`;
+    let url2 = getNamedRoutePath(name) ?? `/${name}`;
     for (const [key, value] of Object.entries(params)) {
-      url2 = url2.replace(`{${key}}`, value);
+      const encoded = encodeURIComponent(value);
+      url2 = url2.replace(`{${key}}`, encoded);
+      url2 = url2.replace(`{${key}?}`, encoded);
+    }
+    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) {
@@ -6158,171 +5656,6 @@ var RouterUtils = {
 };
 var router = new FluentRouter;
 
-// src/utils.ts
-import { join as join3 } from "path";
-function normalizePath(path) {
-  let normalizedPath = path.replace(/\/+/g, "/");
-  if (!normalizedPath.startsWith("/")) {
-    normalizedPath = `/${normalizedPath}`;
-  }
-  if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
-    normalizedPath = normalizedPath.slice(0, -1);
-  }
-  return normalizedPath;
-}
-function toActionPath(path) {
-  return path.replace(/\//g, "_").toLowerCase();
-}
-function isActionClass(handler) {
-  if (typeof handler !== "function" && typeof handler !== "object") {
-    return false;
-  }
-  if (typeof handler === "function" && handler.prototype) {
-    const prototype = handler.prototype;
-    if (typeof prototype.handle === "function") {
-      return true;
-    }
-  }
-  if (typeof handler === "object" && handler !== null && "handle" in handler && typeof handler.handle === "function") {
-    return true;
-  }
-  return false;
-}
-function isRouteHandler(handler) {
-  return typeof handler === "function" && !isActionClass(handler);
-}
-function extractParamNames(pattern) {
-  const matches = pattern.match(/\{([^}]+)\}/g);
-  return matches ? matches.map((m) => m.slice(1, -1).replace("?", "")) : [];
-}
-function createPathRegex(pattern) {
-  const regexPattern = pattern.replace(/\{([^}]+)\}/g, "([^/]+)");
-  return new RegExp(`^${regexPattern}$`);
-}
-function matchPath(pattern, path, params, constraints) {
-  const normalizedPattern = normalizePath(pattern);
-  const normalizedPath = normalizePath(path);
-  if (pattern.endsWith("/*")) {
-    const basePattern = pattern.slice(0, -2);
-    if (path.startsWith(basePattern)) {
-      return true;
-    }
-  }
-  const patternSegments = normalizedPattern.split("/").filter(Boolean);
-  const pathSegments = normalizedPath.split("/").filter(Boolean);
-  const optionalParamCount = (normalizedPattern.match(/\{[^}]+\?\}/g) || []).length;
-  if (pathSegments.length < patternSegments.length - optionalParamCount || pathSegments.length > patternSegments.length) {
-    return false;
-  }
-  for (let i = 0;i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-    const pathSegment = pathSegments[i];
-    if (pathSegment === undefined) {
-      if (patternSegment.match(/\{[^}]+\?\}/)) {
-        continue;
-      } else {
-        return false;
-      }
-    }
-    const paramMatch = patternSegment.match(/\{([^}:]+)(?::[^}]+)?(\?)?\}/);
-    if (paramMatch) {
-      const paramName = paramMatch[1].replace("?", "");
-      params[paramName] = pathSegment;
-      if (constraints && constraints[paramName]) {
-        try {
-          const regex = new RegExp(`^${constraints[paramName]}$`);
-          if (!regex.test(pathSegment)) {
-            return false;
-          }
-        } catch {
-          console.warn(`Invalid constraint regex for parameter ${paramName}: ${constraints[paramName]}`);
-        }
-      }
-    } else if (patternSegment !== pathSegment) {
-      return false;
-    }
-  }
-  return true;
-}
-function joinPaths(...segments) {
-  return normalizePath(segments.join("/"));
-}
-function validatePath(path) {
-  if (!path.startsWith("/")) {
-    return false;
-  }
-  const stack = [];
-  for (const char of path) {
-    if (char === "{") {
-      stack.push(char);
-    } else if (char === "}") {
-      if (stack.length === 0 || stack.pop() !== "{") {
-        return false;
-      }
-    }
-  }
-  return stack.length === 0;
-}
-async function fileExists(path) {
-  try {
-    const file = Bun.file(path);
-    return await file.exists();
-  } catch {
-    return false;
-  }
-}
-async function resolveViewPath(viewName, viewsPath, extensions) {
-  if (extensions.some((ext) => viewName.endsWith(ext))) {
-    const fullPath = normalizePath(join3(viewsPath, viewName));
-    if (await fileExists(fullPath)) {
-      return fullPath;
-    }
-    return null;
-  }
-  for (const ext of extensions) {
-    const fullPath = normalizePath(join3(viewsPath, `${viewName}${ext}`));
-    if (await fileExists(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
-function processHtmlTemplate(template, data) {
-  let result = template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-    const trimmedKey = key.trim();
-    const value = getNestedValue(data, trimmedKey);
-    return value !== undefined ? String(value) : match;
-  });
-  result = processConditionals(result, data);
-  result = processLoops(result, data);
-  return result;
-}
-function processConditionals(template, data) {
-  return template.replace(/\{\{#if ([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (_match, condition, content, alternative = "") => {
-    const conditionTrimmed = condition.trim();
-    const value = getNestedValue(data, conditionTrimmed);
-    return value ? content : alternative;
-  });
-}
-function processLoops(template, data) {
-  return template.replace(/\{\{#each ([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (_match, arrayKey, content) => {
-    const array = getNestedValue(data, arrayKey.trim());
-    if (!Array.isArray(array))
-      return "";
-    return array.map((item) => {
-      return content.replace(/\{\{@index\}\}/g, String(array.indexOf(item))).replace(/\{\{this\}\}/g, String(item)).replace(/\{\{this\.([^}]+)\}\}/g, (_matchStr, prop) => {
-        const value = item[prop.trim()];
-        return value !== undefined ? String(value) : "";
-      });
-    }).join("");
-  });
-}
-function getNestedValue(obj, path) {
-  return path.split(".").reduce((prev, curr) => {
-    return prev && prev[curr] !== undefined ? prev[curr] : undefined;
-  }, obj);
-}
-
 // src/router/group-organization.ts
 function registerGroupOrganization(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
@@ -6342,7 +5675,16 @@ function registerGroupOrganization(RouterClass) {
           ];
         }
         this.currentGroup = newGroup;
-        callback();
+        const result = callback();
+        if (result instanceof Promise) {
+          return result.then(() => {
+            this.currentGroup = previousGroup;
+            return this;
+          }, (error) => {
+            this.currentGroup = previousGroup;
+            throw error;
+          });
+        }
         this.currentGroup = previousGroup;
         return this;
       },
@@ -6539,10 +5881,11 @@ function registerHttpMethods(RouterClass) {
           this.namedRoutes.set(name, route);
           registerNamedRoute(name, route.path);
         }
-        if (this.addRouteToCompiler) {
+        if (this.addRouteToCompiler && !domain) {
           this.addRouteToCompiler(route);
         }
         this.routeCache.clear();
+        this._allowedMethodsCache?.clear();
         return this;
       },
       writable: true,
@@ -6590,6 +5933,13 @@ function registerHttpMethods(RouterClass) {
       writable: true,
       configurable: true
     },
+    head: {
+      value(path, handler, type, name, middleware2) {
+        return this.addRoute("HEAD", path, handler, type, name, middleware2);
+      },
+      writable: true,
+      configurable: true
+    },
     match: {
       value(methods, path, handler, type, name, middleware2) {
         for (const method of methods) {
@@ -6627,6 +5977,12 @@ function registerHttpMethods(RouterClass) {
           url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
           url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
         }
+        if (url2.includes("{")) {
+          url2 = url2.replace(/\{[^}]+\?\}/g, "").replace(/\/{2,}/g, "/");
+          if (url2.length > 1 && url2.endsWith("/")) {
+            url2 = url2.slice(0, -1);
+          }
+        }
         return url2;
       },
       writable: true,
@@ -6837,6 +6193,19 @@ Last error: ${lastError?.message || "Unknown error"}`);
 function createHandlerResolver(config2) {
   return (handler, req) => resolveHandler(handler, req, config2);
 }
+function createHandlerInvoker(handler, config2) {
+  if (handler instanceof Response) {
+    return async () => handler.clone();
+  }
+  if (isCallableHandler(handler)) {
+    return async (req) => wrapResponse(await handler(req));
+  }
+  if (typeof handler === "function" && handler.prototype && typeof handler.prototype.handle === "function") {
+    const HandlerClass = handler;
+    return async (req) => wrapResponse(await new HandlerClass().handle(req));
+  }
+  return (req) => resolveHandler(handler, req, config2);
+}
 
 // src/router/middleware.ts
 function registerMiddlewareHandling(RouterClass) {
@@ -6849,6 +6218,7 @@ function registerMiddlewareHandling(RouterClass) {
             this.globalMiddleware.push(resolvedMiddleware);
           }
         }
+        this._mwEpoch = (this._mwEpoch || 0) + 1;
         return this;
       },
       writable: true,
@@ -7495,40 +6865,36 @@ class RouteTrie {
       return null;
     }
     const segment = segments[segmentIndex];
-    const candidates = [];
-    if (node.children.has(segment)) {
-      candidates.push({
-        node: node.children.get(segment),
-        newParams: { ...params }
-      });
-    }
-    if (node.paramChild) {
-      const paramNode = node.paramChild;
-      let matches = true;
-      if (paramNode.pattern) {
-        matches = paramNode.pattern.test(segment);
-      }
-      if (matches && paramNode.paramName) {
-        candidates.push({
-          node: paramNode,
-          newParams: { ...params, [paramNode.paramName]: segment }
-        });
-      }
+    const staticChild = node.children.get(segment);
+    if (staticChild) {
+      const match = this.matchSegments(staticChild, segments, segmentIndex + 1, params, method);
+      if (match)
+        return match;
     }
-    if (node.wildcardChild) {
-      const remainingPath = segments.slice(segmentIndex).join("/");
-      const match = this.matchSegments(node.wildcardChild, [], 0, { ...params, wildcard: remainingPath }, method);
+    const paramNode = node.paramChild;
+    if (paramNode && paramNode.paramName && (!paramNode.pattern || paramNode.pattern.test(segment))) {
+      const previous = params[paramNode.paramName];
+      params[paramNode.paramName] = segment;
+      const match = this.matchSegments(paramNode, segments, segmentIndex + 1, params, method);
       if (match)
         return match;
+      if (previous === undefined)
+        delete params[paramNode.paramName];
+      else
+        params[paramNode.paramName] = previous;
     }
-    let bestMatch = null;
-    for (const candidate of candidates) {
-      const match = this.matchSegments(candidate.node, segments, segmentIndex + 1, candidate.newParams, method);
-      if (match && (!bestMatch || match.score > bestMatch.score)) {
-        bestMatch = match;
+    if (node.wildcardChild) {
+      const compiled = node.wildcardChild.getRoute(method);
+      if (compiled) {
+        params.wildcard = segments.slice(segmentIndex).join("/");
+        return {
+          route: compiled.route,
+          params,
+          score: compiled.priority
+        };
       }
     }
-    return bestMatch;
+    return null;
   }
   getAllRoutes() {
     return Array.from(this.compiledRoutes.values());
@@ -7582,7 +6948,7 @@ class RouteTrie {
 class RouteCompiler {
   trie;
   matchCache = new Map;
-  cacheKeys = [];
+  routeKeys = new Set;
   stats = {
     totalMatches: 0,
     cacheHits: 0,
@@ -7599,6 +6965,7 @@ class RouteCompiler {
       enablePriorityOptimization: true,
       cacheSize: 1000,
       precompilePatterns: true,
+      enableProfiling: false,
       ...options
     };
     this.trie = new RouteTrie;
@@ -7607,10 +6974,11 @@ class RouteCompiler {
     if (this.options.precompilePatterns) {
       this.precompileRoutePattern(route);
     }
-    const isDuplicate = this.checkForDuplicateRoute(route);
-    if (isDuplicate) {
+    const routeKey = `${route.method}:${route.path}`;
+    if (this.routeKeys.has(routeKey)) {
       return false;
     }
+    this.routeKeys.add(routeKey);
     this.trie.addRoute(route);
     if (this.options.enableCaching) {
       this.matchCache.clear();
@@ -7619,15 +6987,6 @@ class RouteCompiler {
     this.stats.methodDistribution[method] = (this.stats.methodDistribution[method] || 0) + 1;
     return true;
   }
-  checkForDuplicateRoute(route) {
-    const routes = this.trie.getAllRoutes();
-    for (const existingRoute of routes) {
-      if (existingRoute.route.path === route.path && existingRoute.route.method === route.method) {
-        return true;
-      }
-    }
-    return false;
-  }
   patternCache = new Map;
   extractParamNames(path) {
     const paramNames = [];
@@ -7670,17 +7029,25 @@ class RouteCompiler {
     }
   }
   convertToURLPattern(path, constraints) {
-    let regexPattern = path.replace(/\{([^}:]+)(?::([^}]+))?\}/g, (_match, name, ..._args) => {
-      const pattern = _args[0];
-      if (constraints && constraints[name]) {
-        return `(?<${name}>${constraints[name]})`;
-      } else if (pattern) {
-        return `(?<${name}>${pattern})`;
-      }
-      return `(?<${name}>[^/]+)`;
+    const paramTokens = [];
+    const withTokens = path.replace(/\{([^}]+)\}/g, (_m, inner) => {
+      paramTokens.push(inner);
+      return `\x00${paramTokens.length - 1}\x00`;
+    });
+    let regexPattern = withTokens.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+    regexPattern = regexPattern.replace(/\/?\u0000(\d+)\u0000/g, (token, idx) => {
+      const inner = paramTokens[Number(idx)];
+      const isOptional = inner.endsWith("?");
+      const core = isOptional ? inner.slice(0, -1) : inner;
+      const colonIndex = core.indexOf(":");
+      const name = colonIndex === -1 ? core : core.slice(0, colonIndex);
+      const inlinePattern = colonIndex === -1 ? undefined : core.slice(colonIndex + 1);
+      const pattern = constraints?.[name] ?? inlinePattern ?? "[^/]+";
+      const group = `(?<${name}>${pattern})`;
+      const leadingSlash = token.startsWith("/") ? "/" : "";
+      return isOptional ? `(?:${leadingSlash}${group})?` : `${leadingSlash}${group}`;
     });
-    regexPattern = `^${regexPattern.replace(/\//g, "\\/")}$`;
-    const regex = new RegExp(regexPattern);
+    const regex = new RegExp(`^${regexPattern}$`);
     return {
       exec: (pathname) => {
         const match = pathname.match(regex);
@@ -7693,16 +7060,16 @@ class RouteCompiler {
     };
   }
   match(path, method) {
-    const startTime = performance.now();
+    const startTime = this.options.enableProfiling ? performance.now() : 0;
     this.stats.totalMatches++;
     if (this.options.enableCaching) {
       const cacheKey = `${method}:${path}`;
-      if (this.matchCache.has(cacheKey)) {
+      const cached = this.matchCache.get(cacheKey);
+      if (cached !== undefined || this.matchCache.has(cacheKey)) {
         this.stats.cacheHits++;
-        this.updateCacheLRU(cacheKey);
-        const cached = this.matchCache.get(cacheKey);
-        this.updateMatchTime(startTime);
-        return cached || null;
+        if (startTime)
+          this.updateMatchTime(startTime);
+        return cached ? { route: cached.route, params: { ...cached.params } } : null;
       }
       this.stats.cacheMisses++;
     }
@@ -7718,25 +7085,18 @@ class RouteCompiler {
       const cacheKey = `${method}:${path}`;
       this.addToCache(cacheKey, result);
     }
-    this.updateMatchTime(startTime);
-    return result;
+    if (startTime)
+      this.updateMatchTime(startTime);
+    return result ? { route: result.route, params: { ...result.params } } : null;
   }
   addToCache(key, value) {
     if (this.matchCache.size >= this.options.cacheSize && !this.matchCache.has(key)) {
-      if (this.cacheKeys.length > 0) {
-        const lruKey = this.cacheKeys.shift();
+      const lruKey = this.matchCache.keys().next().value;
+      if (lruKey !== undefined) {
         this.matchCache.delete(lruKey);
       }
     }
     this.matchCache.set(key, value);
-    this.updateCacheLRU(key);
-  }
-  updateCacheLRU(key) {
-    const index = this.cacheKeys.indexOf(key);
-    if (index !== -1) {
-      this.cacheKeys.splice(index, 1);
-    }
-    this.cacheKeys.push(key);
   }
   updateMatchTime(startTime) {
     const matchTime = performance.now() - startTime;
@@ -7805,7 +7165,7 @@ class RouteCompiler {
   clear() {
     this.trie.clear();
     this.matchCache.clear();
-    this.cacheKeys = [];
+    this.routeKeys.clear();
     this.stats = {
       totalMatches: 0,
       cacheHits: 0,
@@ -7999,14 +7359,25 @@ function registerOptimizedRouteMatching(RouterClass) {
     matchRoute: {
       value(path, method, domain) {
         this.initializeRouteCompiler();
-        const match = this.routeCompiler.match(path, method);
-        if (match) {
-          if (domain && match.route.domain && match.route.domain !== domain) {
-            return;
+        if (domain && this.domains[domain]) {
+          const domainMatch = this.fallbackMatchRoute(path, method, domain);
+          if (domainMatch) {
+            return domainMatch;
+          }
+        } else {
+          const match = this.routeCompiler.match(path, method);
+          if (match && (!domain || !match.route.domain || match.route.domain === domain)) {
+            return match;
+          }
+          const fallback = this.fallbackMatchRoute(path, method, domain);
+          if (fallback) {
+            return fallback;
           }
-          return match;
         }
-        return this.fallbackMatchRoute(path, method, domain);
+        if (method === "HEAD") {
+          return this.matchRoute(path, "GET", domain);
+        }
+        return;
       },
       writable: true,
       configurable: true
@@ -8018,6 +7389,9 @@ function registerOptimizedRouteMatching(RouterClass) {
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
+        if (this.routeCache.size >= 1e4) {
+          this.routeCache.clear();
+        }
         if (this.staticRoutes.has(method)) {
           const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
@@ -8054,6 +7428,24 @@ function registerOptimizedRouteMatching(RouterClass) {
             }
           }
         }
+        const wildcardPools = domain && this.domains[domain] ? [this.domains[domain], this.routes] : [this.routes];
+        for (const pool of wildcardPools) {
+          for (const route of pool) {
+            if (route.method !== method || !route.path.endsWith("*")) {
+              continue;
+            }
+            const basePath = route.path.slice(0, -1);
+            if (url2.pathname.startsWith(basePath)) {
+              const result = {
+                route,
+                params: { wildcard: url2.pathname.slice(basePath.length) }
+              };
+              this.routeCache.set(cacheKey, result);
+              return result;
+            }
+          }
+        }
+        this.routeCache.set(cacheKey, undefined);
         return;
       },
       writable: true,
@@ -8472,6 +7864,17 @@ function registerRouteMatching(RouterClass) {
       writable: true,
       configurable: true
     },
+    withoutNativeDispatch: {
+      value() {
+        const lastRoute = this.routes[this.routes.length - 1];
+        if (lastRoute) {
+          lastRoute.nativeDispatch = false;
+        }
+        return this;
+      },
+      writable: true,
+      configurable: true
+    },
     whereNumber: {
       value(param) {
         return this.where({ [param]: "\\d+" });
@@ -8534,6 +7937,8 @@ class Router {
   namedMiddleware = new Map;
   conditionalMiddleware = [];
   _middlewarePipeline;
+  _mwEpoch = 0;
+  _allowedMethodsCache = new Map;
   config = {
     verbose: false,
     routesPath: "routes",
@@ -8634,6 +8039,7 @@ class Router {
   }
   invalidateCache() {
     this.routeCache.clear();
+    this._allowedMethodsCache.clear();
   }
   registerRoute(method, path, handler, type, name, middleware2) {
     let routePath = path;
@@ -8948,50 +8354,44 @@ class Router {
   }
   getAllowedMethods(path, domain) {
     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;
-    const allMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
-    for (const method of allMethods) {
-      if (this.staticRoutes.has(method)) {
-        const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
-        if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
-          methods.add(method);
-          continue;
-        }
+    for (const [method, routesByPath] of this.staticRoutes) {
+      const staticRoute = routesByPath.get(url2.pathname);
+      if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
+        methods.add(method);
+      }
+    }
+    const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
+    for (const route of potentialRoutes) {
+      if (methods.has(route.method)) {
+        continue;
       }
-      const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
-      const methodRoutes = potentialRoutes.filter((route) => route.method === method);
-      for (const route of methodRoutes) {
-        if (route.path === url2.pathname) {
-          methods.add(method);
-          break;
-        }
+      if (route.path === url2.pathname) {
+        methods.add(route.method);
+        continue;
       }
-      if (!methods.has(method)) {
-        for (const route of methodRoutes) {
-          if (route.pattern) {
-            const match = route.pattern.exec(url2);
-            if (match) {
-              methods.add(method);
-              break;
-            }
-          }
-        }
+      if (route.pattern && route.pattern.exec(url2)) {
+        methods.add(route.method);
+        continue;
       }
-      if (!methods.has(method)) {
-        const wildcardRoutes = potentialRoutes.filter((route) => route.method === method && route.path.endsWith("*"));
-        for (const route of wildcardRoutes) {
-          const basePath = route.path.slice(0, -1);
-          if (url2.pathname.startsWith(basePath)) {
-            methods.add(method);
-            break;
-          }
-        }
+      if (route.path.endsWith("*") && url2.pathname.startsWith(route.path.slice(0, -1))) {
+        methods.add(route.method);
       }
     }
     if (methods.has("GET")) {
       methods.add("HEAD");
     }
-    return Array.from(methods);
+    const result = Array.from(methods);
+    if (this._allowedMethodsCache.size >= 1e4) {
+      this._allowedMethodsCache.clear();
+    }
+    this._allowedMethodsCache.set(cacheKey, result);
+    return result;
   }
   matchRoute(path, method, domain) {
     const url2 = new URL(path, "http://localhost");
@@ -9419,12 +8819,15 @@ class Router {
     }
     const result = callback();
     if (result instanceof Promise) {
-      result.then(() => {
+      return result.then(() => {
+        this.currentGroup = previousGroup;
+        return this;
+      }, (error) => {
         this.currentGroup = previousGroup;
+        throw error;
       });
-    } else {
-      this.currentGroup = previousGroup;
     }
+    this.currentGroup = previousGroup;
     return this;
   }
   addRoute(route) {
@@ -9556,10 +8959,48 @@ function applyRequestEnhancements(req, params = {}) {
 }
 
 // src/request/macros.ts
+var MOBILE_REGEX = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+var BOT_REGEX = /bot|crawler|spider|crawling/i;
+var GLOB_PATTERN_CACHE = new Map;
+function getParsedURL(req) {
+  const cache = req;
+  if (!cache._parsedURL) {
+    cache._parsedURL = new URL(req.url);
+  }
+  return cache._parsedURL;
+}
+function getParsedCookies(req) {
+  const cache = req;
+  if (!cache._parsedCookies) {
+    const cookies = {};
+    const cookieHeader = req.headers.get("cookie");
+    if (cookieHeader) {
+      for (const cookie of cookieHeader.split(";")) {
+        const eqIndex = cookie.indexOf("=");
+        if (eqIndex === -1)
+          continue;
+        const key = cookie.slice(0, eqIndex).trim();
+        if (!key)
+          continue;
+        const value = cookie.slice(eqIndex + 1).trim();
+        try {
+          cookies[key] = decodeURIComponent(value);
+        } catch {
+          cookies[key] = value;
+        }
+      }
+    }
+    cache._parsedCookies = cookies;
+  }
+  return cache._parsedCookies;
+}
+
 class RequestMacroRegistry {
   macros = new Map;
-  register(name, handler) {
-    this.macros.set(name, { name, handler });
+  epoch = 0;
+  register(name, handler, accessor = false) {
+    this.macros.set(name, { name, handler, accessor });
+    this.epoch++;
   }
   get(name) {
     return this.macros.get(name);
@@ -9571,23 +9012,71 @@ class RequestMacroRegistry {
     return Array.from(this.macros.values());
   }
   remove(name) {
-    return this.macros.delete(name);
+    const removed = this.macros.delete(name);
+    if (removed)
+      this.epoch++;
+    return removed;
   }
   clear() {
     this.macros.clear();
+    this.epoch++;
+  }
+  getEpoch() {
+    return this.epoch;
   }
 }
 var requestMacroRegistry = new RequestMacroRegistry;
+var MACRO_PROTO = Symbol("bunRouterMacroProto");
+var MACRO_BASE = Symbol("bunRouterMacroBase");
+var macroProtoCache = new WeakMap;
+var macroProtoEpoch = -1;
 
 class RequestWithMacros {
   static macro(name, handler) {
     requestMacroRegistry.register(name, handler);
   }
+  static macroAccessor(name, getter) {
+    requestMacroRegistry.register(name, getter, true);
+  }
   static applyMacros(request2) {
-    const macros = requestMacroRegistry.all();
-    macros.forEach((macro) => {
-      request2[macro.name] = macro.handler.bind(request2);
-    });
+    const epoch = requestMacroRegistry.getEpoch();
+    if (epoch !== macroProtoEpoch) {
+      macroProtoCache = new WeakMap;
+      macroProtoEpoch = epoch;
+    }
+    let base = Object.getPrototypeOf(request2) ?? Object.prototype;
+    if (base[MACRO_PROTO]) {
+      if (macroProtoCache.get(base[MACRO_BASE]) === base) {
+        return request2;
+      }
+      base = base[MACRO_BASE];
+    }
+    let proto = macroProtoCache.get(base);
+    if (!proto) {
+      proto = Object.create(base);
+      for (const macro of requestMacroRegistry.all()) {
+        if (macro.accessor) {
+          Object.defineProperty(proto, macro.name, {
+            get: macro.handler,
+            set(value) {
+              Object.defineProperty(this, macro.name, {
+                value,
+                writable: true,
+                configurable: true,
+                enumerable: true
+              });
+            },
+            configurable: true
+          });
+        } else {
+          proto[macro.name] = macro.handler;
+        }
+      }
+      Object.defineProperty(proto, MACRO_PROTO, { value: true });
+      Object.defineProperty(proto, MACRO_BASE, { value: base });
+      macroProtoCache.set(base, proto);
+    }
+    Object.setPrototypeOf(request2, proto);
     return request2;
   }
   static hasMacro(name) {
@@ -9617,14 +9106,10 @@ var BuiltInRequestMacros = {
     return this.headers.get("x-pjax") === "true";
   },
   isMobile() {
-    const userAgent = this.headers.get("user-agent") || "";
-    const mobileRegex = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
-    return mobileRegex.test(userAgent);
+    return MOBILE_REGEX.test(this.headers.get("user-agent") || "");
   },
   isBot() {
-    const userAgent = this.headers.get("user-agent") || "";
-    const botRegex = /bot|crawler|spider|crawling/i;
-    return botRegex.test(userAgent);
+    return BOT_REGEX.test(this.headers.get("user-agent") || "");
   },
   isSecure() {
     return this.url.startsWith("https://") || this.headers.get("x-forwarded-proto") === "https" || this.headers.get("x-forwarded-ssl") === "on";
@@ -9652,6 +9137,17 @@ var BuiltInRequestMacros = {
     }
     return null;
   },
+  async rawBody() {
+    if (typeof this._rawBody === "string")
+      return this._rawBody;
+    try {
+      const text = await this.clone().text();
+      this._rawBody = text;
+      return text;
+    } catch {
+      return "";
+    }
+  },
   basicAuth() {
     const auth2 = this.headers.get("authorization");
     if (auth2 && auth2.startsWith("Basic ")) {
@@ -9756,30 +9252,11 @@ var BuiltInRequestMacros = {
     return this.params?.[key] || defaultValue;
   },
   cookie(name, defaultValue) {
-    const cookies = this.headers.get("cookie");
-    if (!cookies)
-      return defaultValue || null;
-    const cookieArray = cookies.split(";");
-    for (const cookie of cookieArray) {
-      const [key, value] = cookie.trim().split("=");
-      if (key === name) {
-        return decodeURIComponent(value);
-      }
-    }
-    return defaultValue || null;
+    const value = getParsedCookies(this)[name];
+    return value !== undefined ? value : defaultValue || null;
   },
   cookies() {
-    const cookies = {};
-    const cookieHeader = this.headers.get("cookie");
-    if (cookieHeader) {
-      cookieHeader.split(";").forEach((cookie) => {
-        const [key, value] = cookie.trim().split("=");
-        if (key && value) {
-          cookies[key] = decodeURIComponent(value);
-        }
-      });
-    }
-    return cookies;
+    return { ...getParsedCookies(this) };
   },
   file(name) {
     return this.files?.find((f) => f.fieldName === name);
@@ -9788,26 +9265,33 @@ var BuiltInRequestMacros = {
     return !!this.files?.find((f) => f.fieldName === name);
   },
   path() {
-    return new URL(this.url).pathname;
+    return getParsedURL(this).pathname;
   },
   fullUrl() {
     return this.url;
   },
   root() {
-    const url2 = new URL(this.url);
+    const url2 = getParsedURL(this);
     return `${url2.protocol}//${url2.host}`;
   },
   is(pattern) {
     const path = this.path();
-    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-    const regex = new RegExp(`^${regexPattern}$`);
+    let regex = GLOB_PATTERN_CACHE.get(pattern);
+    if (!regex) {
+      const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+      regex = new RegExp(`^${regexPattern}$`);
+      if (GLOB_PATTERN_CACHE.size >= 1000) {
+        GLOB_PATTERN_CACHE.clear();
+      }
+      GLOB_PATTERN_CACHE.set(pattern, regex);
+    }
     return regex.test(path);
   },
   route() {
     return this.routeName || null;
   },
   fingerprint() {
-    const url2 = new URL(this.url);
+    const url2 = getParsedURL(this);
     const data = {
       method: this.method,
       path: url2.pathname,
@@ -9863,6 +9347,51 @@ function registerBuiltInRequestMacros() {
 registerBuiltInRequestMacros();
 
 // src/router/server.ts
+if (!RequestWithMacros.hasMacro("getParam")) {
+  RequestWithMacros.macro("getParam", function(name, defaultValue) {
+    const value = this.params?.[name];
+    return value !== undefined ? value : defaultValue;
+  });
+}
+if (!RequestWithMacros.hasMacro("get")) {
+  RequestWithMacros.macro("get", function(key, defaultValue) {
+    const value = getParsedURL(this).searchParams.get(key);
+    return value !== null && value !== undefined ? value : defaultValue;
+  });
+}
+RequestWithMacros.macroAccessor("cookies", function() {
+  const req = this;
+  const cookies = () => ({ ...getParsedCookies(req) });
+  for (const [key, value] of Object.entries(getParsedCookies(req))) {
+    Object.defineProperty(cookies, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  cookies.get = (name) => getParsedCookies(req)[name];
+  cookies.set = (name, value, options = {}) => {
+    if (!req._cookiesToSet) {
+      req._cookiesToSet = [];
+    }
+    req._cookiesToSet.push({ name, value, options });
+  };
+  cookies.delete = (name, options = {}) => {
+    if (!req._cookiesToDelete) {
+      req._cookiesToDelete = [];
+    }
+    req._cookiesToDelete.push({ name, options });
+  };
+  cookies.getAll = () => ({ ...getParsedCookies(req) });
+  Object.defineProperty(req, "cookies", {
+    value: cookies,
+    writable: true,
+    configurable: true,
+    enumerable: true
+  });
+  return cookies;
+});
 function registerServerHandling(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     serve: {
@@ -9894,6 +9423,13 @@ function registerServerHandling(RouterClass) {
         if (options.development !== undefined) {
           serverOptions.development = options.development;
         }
+        this._nativeRoutesEnabled = options.nativeRoutes === true;
+        if (this._nativeRoutesEnabled) {
+          const nativeRoutes = this._buildNativeRoutes();
+          if (nativeRoutes) {
+            serverOptions.routes = nativeRoutes;
+          }
+        }
         if (this.wsConfig) {
           serverOptions.websocket = this.wsConfig;
         }
@@ -9919,12 +9455,19 @@ function registerServerHandling(RouterClass) {
         const port = this.serverInstance.port;
         const hostname = this.serverInstance.hostname;
         this.serverInstance.stop();
-        this.serverInstance = Bun.serve({
+        const reloadOptions = {
           port,
           hostname,
           fetch: this.handleRequest.bind(this),
           websocket: this.wsConfig || undefined
-        });
+        };
+        if (this._nativeRoutesEnabled) {
+          const nativeRoutes = this._buildNativeRoutes();
+          if (nativeRoutes) {
+            reloadOptions.routes = nativeRoutes;
+          }
+        }
+        this.serverInstance = Bun.serve(reloadOptions);
         if (this.config.verbose) {
           console.log(`\uD83D\uDD04 Server reloaded at http://${hostname}:${port}`);
         }
@@ -9940,46 +9483,177 @@ function registerServerHandling(RouterClass) {
       writable: true,
       configurable: true
     },
+    _dispatchMatchedRoute: {
+      async value(matchedRoute, req, params) {
+        const enhancedReq = this.enhanceRequest(req, params);
+        setCurrentRequest(enhancedReq);
+        enhancedReq.route = matchedRoute;
+        const route = matchedRoute;
+        const epoch = this._mwEpoch || 0;
+        const routeMwLen = route.middleware ? route.middleware.length : 0;
+        let chain = route._compiledChain;
+        if (!chain || route._chainEpoch !== epoch || route._chainMwLen !== routeMwLen) {
+          const invoke = createHandlerInvoker(route.handler, this.config);
+          if (routeMwLen === 0 && this.globalMiddleware.length === 0) {
+            chain = invoke;
+          } else {
+            const middlewareStack = routeMwLen > 0 ? [...this.globalMiddleware, ...route.middleware] : [...this.globalMiddleware];
+            middlewareStack.push((handlerReq, _next) => invoke(handlerReq));
+            chain = this.buildMiddlewareChain(middlewareStack);
+          }
+          route._compiledChain = chain;
+          route._chainEpoch = epoch;
+          route._chainMwLen = routeMwLen;
+        }
+        let response2;
+        try {
+          response2 = await chain(enhancedReq);
+        } catch (error) {
+          if (this.errorHandler) {
+            response2 = await this.errorHandler(error);
+          } else {
+            throw error;
+          }
+        }
+        if (response2) {
+          return this.applyModifiedCookies(response2, enhancedReq);
+        }
+        return new Response("No response from middleware chain", { status: 500 });
+      },
+      writable: true,
+      configurable: true
+    },
+    _buildNativeRoutes: {
+      value() {
+        const NATIVE_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]);
+        const convertPath = (path) => {
+          if (path === "*") {
+            return "/*";
+          }
+          const segments = path.split("/");
+          const converted = [];
+          for (let i = 0;i < segments.length; i++) {
+            const segment = segments[i];
+            if (segment === "") {
+              converted.push(segment);
+              continue;
+            }
+            if (segment === "*") {
+              return i === segments.length - 1 ? [...converted, "*"].join("/") : null;
+            }
+            const paramMatch = segment.match(/^\{([A-Z_$][\w$]*)\}$/i);
+            if (paramMatch) {
+              converted.push(`:${paramMatch[1]}`);
+              continue;
+            }
+            if (segment.includes("{") || segment.includes(":") || segment.includes("*")) {
+              return null;
+            }
+            converted.push(segment);
+          }
+          return converted.join("/");
+        };
+        const self = this;
+        const wrapRoute = (route, isWildcard) => {
+          return (req) => {
+            return runWithRequest(req, async () => {
+              try {
+                let params = req.params ?? {};
+                if (isWildcard) {
+                  const pathname = new URL(req.url).pathname;
+                  const basePath = route.path === "*" ? "/" : route.path.slice(0, -1);
+                  params = { ...params, wildcard: pathname.slice(basePath.length) };
+                }
+                return await self._dispatchMatchedRoute(route, req, params);
+              } catch (error) {
+                console.error("Error handling request:", error);
+                if (self.errorHandler) {
+                  return self.errorHandler(error);
+                }
+                return new Response(JSON.stringify({
+                  success: false,
+                  message: "Internal Server Error",
+                  error: error instanceof Error ? error.message : String(error)
+                }), {
+                  status: 500,
+                  headers: {
+                    "Content-Type": "application/json",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
+                  }
+                });
+              }
+            });
+          };
+        };
+        const natives = {};
+        const claimedShapes = new Map;
+        for (const route of this.routes) {
+          if (!NATIVE_METHODS.has(route.method)) {
+            continue;
+          }
+          if (route.nativeDispatch === false) {
+            continue;
+          }
+          if (route.constraints && Object.keys(route.constraints).length > 0) {
+            continue;
+          }
+          if (route.handler instanceof Response) {
+            continue;
+          }
+          const bunPath = convertPath(route.path);
+          if (!bunPath) {
+            continue;
+          }
+          const shape = bunPath.replace(/:[^/]+/g, ":p");
+          const claimedBy = claimedShapes.get(shape);
+          if (claimedBy && claimedBy !== bunPath) {
+            continue;
+          }
+          claimedShapes.set(shape, bunPath);
+          const entry = natives[bunPath] ??= {};
+          if (entry[route.method]) {
+            continue;
+          }
+          entry[route.method] = wrapRoute(route, route.path.endsWith("*"));
+        }
+        for (const entry of Object.values(natives)) {
+          if (entry.GET && !entry.HEAD) {
+            entry.HEAD = entry.GET;
+          }
+        }
+        return Object.keys(natives).length > 0 ? natives : null;
+      },
+      writable: true,
+      configurable: true
+    },
     handleRequestImpl: {
       async value(req) {
         try {
           const url2 = new URL(req.url);
-          if (req.method === "OPTIONS") {
-            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,
-                headers: {
-                  "Access-Control-Allow-Origin": "*",
-                  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-                  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin",
-                  "Access-Control-Max-Age": "86400",
-                  "Access-Control-Allow-Credentials": "true"
-                }
-              });
-            }
-          }
+          req._parsedURL = url2;
           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 || {});
-          setCurrentRequest(enhancedReq);
-          if (match) {
-            enhancedReq.route = match.route;
-            const middlewareStack = [...this.globalMiddleware];
-            if (match.route.middleware && match.route.middleware.length > 0) {
-              middlewareStack.push(...match.route.middleware);
-            }
-            const routeHandlerMiddleware = async (req2, _next) => {
-              return await this.resolveHandler(match.route.handler, req2);
+          if (req.method === "OPTIONS" && !match) {
+            const origin = req.headers.get("origin");
+            const preflightHeaders = {
+              "Access-Control-Allow-Origin": origin || "*",
+              "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+              "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin",
+              "Access-Control-Max-Age": "86400"
             };
-            middlewareStack.push(routeHandlerMiddleware);
-            const response2 = await this.runMiddleware(enhancedReq, middlewareStack);
-            if (response2) {
-              return this.applyModifiedCookies(response2, enhancedReq);
+            if (origin) {
+              preflightHeaders["Access-Control-Allow-Credentials"] = "true";
+              preflightHeaders.Vary = "Origin";
             }
-            return new Response("No response from middleware chain", { status: 500 });
+            return new Response(null, { status: 204, headers: preflightHeaders });
+          }
+          if (match) {
+            return await this._dispatchMatchedRoute(match.route, req, match.params);
           }
+          const enhancedReq = this.enhanceRequest(req, {});
+          setCurrentRequest(enhancedReq);
           const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
           const corsHeaders = {
             "Content-Type": "application/json",
@@ -10052,63 +9726,18 @@ function registerServerHandling(RouterClass) {
     },
     enhanceRequest: {
       value(req, params = {}) {
-        let parsedCookies = null;
-        const getCookies = () => {
-          if (parsedCookies === null) {
-            parsedCookies = {};
-            const cookieHeader = req.headers.get("cookie") || "";
-            cookieHeader.split(";").forEach((cookie) => {
-              const parts = cookie.trim().split("=");
-              if (parts.length >= 2) {
-                const name = parts[0].trim();
-                const value = parts.slice(1).join("=").trim();
-                parsedCookies[name] = decodeURIComponent(value);
-              }
-            });
-          }
-          return parsedCookies;
-        };
-        const cookies = {
-          get: (name) => getCookies()[name],
-          set: (name, value, options = {}) => {
-            const enhancedRequest = req;
-            if (!enhancedRequest._cookiesToSet) {
-              enhancedRequest._cookiesToSet = [];
-            }
-            enhancedRequest._cookiesToSet.push({ name, value, options });
-          },
-          delete: (name, options = {}) => {
-            const enhancedRequest = req;
-            if (!enhancedRequest._cookiesToDelete) {
-              enhancedRequest._cookiesToDelete = [];
-            }
-            enhancedRequest._cookiesToDelete.push({ name, options });
-          },
-          getAll: () => ({ ...getCookies() })
-        };
-        const enhancedReq = Object.assign(req, {
-          params,
-          cookies: getCookies(),
-          _cookiesToSet: [],
-          _cookiesToDelete: []
-        });
-        RequestWithMacros.applyMacros(enhancedReq);
-        enhancedReq.getParam = (name, defaultValue) => {
-          const value = params?.[name];
-          return value !== undefined ? value : defaultValue;
-        };
-        enhancedReq.cookie = (name, defaultValue) => {
-          const value = getCookies()[name];
-          return value !== undefined ? value : defaultValue ?? null;
-        };
-        if (typeof enhancedReq.get !== "function") {
-          enhancedReq.get = (key, defaultValue) => {
-            const url2 = new URL(req.url);
-            const value = url2.searchParams.get(key);
-            return value !== null && value !== undefined ? value : defaultValue;
-          };
+        const enhancedReq = req;
+        if ("params" in req) {
+          Object.defineProperty(enhancedReq, "params", {
+            value: params,
+            writable: true,
+            configurable: true,
+            enumerable: true
+          });
+        } else {
+          enhancedReq.params = params;
         }
-        Object.assign(enhancedReq, { cookies: { ...getCookies(), ...cookies } });
+        RequestWithMacros.applyMacros(enhancedReq);
         return enhancedReq;
       },
       writable: true,
@@ -10116,6 +9745,11 @@ function registerServerHandling(RouterClass) {
     },
     applyModifiedCookies: {
       value(response2, req) {
+        const hasSet = req._cookiesToSet && req._cookiesToSet.length > 0;
+        const hasDelete = req._cookiesToDelete && req._cookiesToDelete.length > 0;
+        if (!hasSet && !hasDelete) {
+          return response2;
+        }
         const newResponse = new Response(response2.body, {
           status: response2.status,
           statusText: response2.statusText,
@@ -10665,6 +10299,7 @@ function registerBuiltInResponseMacros() {
 registerBuiltInResponseMacros();
 
 // src/validation/validator.ts
+var EMAIL_REGEX = /^[A-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[A-Z0-9](?:[A-Z0-9-]*[A-Z0-9])?(?:\.[A-Z0-9](?:[A-Z0-9-]*[A-Z0-9])?)*\.[A-Z]{2,}$/i;
 var BuiltInRules = {
   required: {
     name: "required",
@@ -10703,10 +10338,7 @@ var BuiltInRules = {
   },
   email: {
     name: "email",
-    validate: (value) => {
-      const emailRegex = /^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/;
-      return typeof value === "string" && emailRegex.test(value);
-    },
+    validate: (value) => typeof value === "string" && EMAIL_REGEX.test(value),
     message: "The :field field must be a valid email address."
   },
   url: {
@@ -10876,6 +10508,25 @@ var BuiltInRules = {
     message: "The :field field must be an object."
   }
 };
+var DatabaseRules = {
+  unique: {
+    name: "unique",
+    validate: async (_value, _parameters) => {
+      console.warn('Database validation rule "unique" requires external implementation');
+      return true;
+    },
+    message: "The :field field must be unique."
+  },
+  exists: {
+    name: "exists",
+    validate: async (_value, _parameters) => {
+      console.warn('Database validation rule "exists" requires external implementation');
+      return true;
+    },
+    message: "The selected :field is invalid."
+  }
+};
+
 class Validator {
   rules = {};
   config;
@@ -10979,6 +10630,153 @@ function createValidationMiddleware(rules, config2) {
   };
 }
 
+class ValidationRuleBuilder {
+  rules = [];
+  required() {
+    this.rules.push("required");
+    return this;
+  }
+  string() {
+    this.rules.push("string");
+    return this;
+  }
+  number() {
+    this.rules.push("number");
+    return this;
+  }
+  integer() {
+    this.rules.push("integer");
+    return this;
+  }
+  boolean() {
+    this.rules.push("boolean");
+    return this;
+  }
+  email() {
+    this.rules.push("email");
+    return this;
+  }
+  url() {
+    this.rules.push("url");
+    return this;
+  }
+  min(value) {
+    this.rules.push(`min:${value}`);
+    return this;
+  }
+  max(value) {
+    this.rules.push(`max:${value}`);
+    return this;
+  }
+  between(min, max) {
+    this.rules.push(`between:${min},${max}`);
+    return this;
+  }
+  in(...values) {
+    this.rules.push(`in:${values.join(",")}`);
+    return this;
+  }
+  notIn(...values) {
+    this.rules.push(`not_in:${values.join(",")}`);
+    return this;
+  }
+  regex(pattern) {
+    this.rules.push(`regex:${pattern}`);
+    return this;
+  }
+  alpha() {
+    this.rules.push("alpha");
+    return this;
+  }
+  alphaNum() {
+    this.rules.push("alpha_num");
+    return this;
+  }
+  alphaDash() {
+    this.rules.push("alpha_dash");
+    return this;
+  }
+  date() {
+    this.rules.push("date");
+    return this;
+  }
+  after(date) {
+    this.rules.push(`after:${date}`);
+    return this;
+  }
+  before(date) {
+    this.rules.push(`before:${date}`);
+    return this;
+  }
+  confirmed(field) {
+    this.rules.push(field ? `confirmed:${field}` : "confirmed");
+    return this;
+  }
+  same(field) {
+    this.rules.push(`same:${field}`);
+    return this;
+  }
+  different(field) {
+    this.rules.push(`different:${field}`);
+    return this;
+  }
+  json() {
+    this.rules.push("json");
+    return this;
+  }
+  uuid() {
+    this.rules.push("uuid");
+    return this;
+  }
+  array() {
+    this.rules.push("array");
+    return this;
+  }
+  object() {
+    this.rules.push("object");
+    return this;
+  }
+  unique(table, column) {
+    this.rules.push(column ? `unique:${table},${column}` : `unique:${table}`);
+    return this;
+  }
+  exists(table, column) {
+    this.rules.push(column ? `exists:${table},${column}` : `exists:${table}`);
+    return this;
+  }
+  custom(ruleName, ...parameters) {
+    this.rules.push(parameters.length > 0 ? `${ruleName}:${parameters.join(",")}` : ruleName);
+    return this;
+  }
+  build() {
+    return this.rules.join("|");
+  }
+}
+function rule() {
+  return new ValidationRuleBuilder;
+}
+var ValidationHelpers = {
+  rules(rules) {
+    const result = {};
+    for (const [field, fieldRules] of Object.entries(rules)) {
+      result[field] = fieldRules instanceof ValidationRuleBuilder ? fieldRules.build() : fieldRules;
+    }
+    return result;
+  },
+  async validateValue(value, rules, field = "value") {
+    const validator = new Validator;
+    const errors = await validator.validate({ [field]: value }, { [field]: rules });
+    return errors[field] || [];
+  },
+  async passes(value, rules) {
+    const errors = await this.validateValue(value, rules);
+    return errors.length === 0;
+  },
+  async fails(value, rules) {
+    return !await this.passes(value, rules);
+  }
+};
+
 // src/router/validation-integration.ts
 class RouteBuilder {
   method;
@@ -11015,7 +10813,7 @@ class RouteBuilder {
   }
 }
 
-class FluentRouter2 {
+class ValidationFluentRouter {
   routes = [];
   get(path, handler) {
     return new RouteBuilder("GET", path, handler);
@@ -11128,7 +10926,7 @@ var RouteHelpers = {
   }
 };
 function createFluentRouter() {
-  return new FluentRouter2;
+  return new ValidationFluentRouter;
 }
 var MiddlewareHelpers = {
   compose: (...middleware2) => {
@@ -13782,11 +13580,13 @@ export {
   singleFileUpload,
   signRequest,
   setCurrentRequest,
+  setContainer,
   session,
   securitySuite,
   security,
   scopedBindingHelpers,
   runWithRequest,
+  rule,
   router,
   routeModelHelpers,
   routeCacheManager,
@@ -13825,10 +13625,12 @@ export {
   inputValidation,
   injectQueryPreservationScript,
   imageUpload,
+  globalValidator,
   globalMiddlewarePipeline,
   getNamedRoutes,
   getNamedRoutePath,
   getCurrentRequest,
+  getContainer,
   getConfig,
   generateSessionId,
   generateQueryPreservationScript,
@@ -13841,12 +13643,14 @@ export {
   extractBearerToken,
   extractBasicAuth,
   extractApiKey,
+  enableRequestContext,
   documentUpload,
   defaultQueryPreservationConfig,
   defaultConfig,
   ddosProtection,
   csrf,
   createWebSocketTester,
+  createValidationMiddleware,
   createTestResponse,
   createTestClient,
   createSubdomainMiddleware,
@@ -13868,6 +13672,7 @@ export {
   createFluentRouter,
   createFileUploadTester,
   createEnhancementMiddleware,
+  createContainer,
   createAuthTester,
   cors,
   contentSecurityPolicy,
@@ -13885,7 +13690,11 @@ export {
   applyRequestEnhancements,
   apiKeyAuth,
   WebSocketTester,
+  Validator,
+  ValidationRuleBuilder,
   ValidationMiddlewareBuilder,
+  ValidationHelpers,
+  ValidationFluentRouter,
   ThrottleFactory,
   TestResponseWrapper,
   TestRequestBuilder,
@@ -13951,17 +13760,24 @@ export {
   FileSessionStore,
   FileSecurity,
   exports_errors as Errors,
+  EnvironmentManager,
   EnhancementPresets,
   DomainMatcher,
   DomainGroupBuilder,
   DomainGroup,
   Dependencies,
+  DefaultServiceProviderManager,
   DatabaseSessionStore,
+  DatabaseRules,
   DDoSProtection,
   Csrf,
   Cors,
+  ContextualContainer,
   ContentSecurityPolicy,
+  Container,
   CacheInvalidation,
+  BuiltInRules,
+  BindingBuilder,
   AuthTester,
   auth_default as Auth,
   ApiKeyManager