@stacksjs/bun-router 0.0.5 → 0.0.7

package/dist/index.js

@@ -2763,6 +2763,27 @@ var RouterErrorFactory = {
   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;
+function runWithRequest(initial, fn) {
+  return storage.run({ current: initial }, fn);
+}
+function setCurrentRequest(req) {
+  const store = storage.getStore();
+  if (store)
+    store.current = req;
+}
+function getCurrentRequest() {
+  return storage.getStore()?.current ?? undefined;
+}
+function request() {
+  const req = getCurrentRequest();
+  if (!req) {
+    throw new Error("request() called outside a request scope. It can only be invoked from within a route handler or middleware.");
+  }
+  return req;
+}
 // src/response/response-factory.ts
 var response = {
   json: (data, options = {}) => {
@@ -2858,8 +2879,8 @@ var response = {
   redirectTemporary: (url) => {
     return response.redirect(url, 302);
   },
-  back: (request, fallback = "/") => {
-    const referer = request.headers.get("referer") || fallback;
+  back: (request2, fallback = "/") => {
+    const referer = request2.headers.get("referer") || fallback;
     return response.redirect(referer);
   },
   view: (html, status = 200, headers = {}) => {
@@ -3104,7 +3125,7 @@ class MiddlewarePipeline {
     }
     this.compiledPipelines.set(routeKey, compiled);
   }
-  async execute(routeKey, request, finalHandler) {
+  async execute(routeKey, request2, finalHandler) {
     const startTime = performance.now();
     this.stats.totalExecutions++;
     const pipeline = this.compiledPipelines.get(routeKey);
@@ -3114,7 +3135,7 @@ class MiddlewarePipeline {
     }
     this.stats.cacheHits++;
     const context = {
-      request,
+      request: request2,
       dependencies: new Map,
       metadata: {}
     };
@@ -3129,7 +3150,7 @@ class MiddlewarePipeline {
         this.stats.skippedMiddleware++;
         return await next();
       }
-      const result2 = await middleware2.handler(request, next);
+      const result2 = await middleware2.handler(request2, next);
       if (result2 instanceof Response && middleware2.canShortCircuit) {
         this.stats.shortCircuits++;
         return result2;
@@ -4193,12 +4214,12 @@ class StreamHandler {
   }
 }
 class FileStreamHandler {
-  static async streamFile(filePath, request, options = {}) {
+  static async streamFile(filePath, request2, options = {}) {
     const { contentType, enableRanges = true, chunkSize: _chunkSize = 64 * 1024 } = options;
     try {
       const file = Bun.file(filePath);
       const fileSize = file.size;
-      const range = enableRanges ? request.headers.get("range") : null;
+      const range = enableRanges ? request2.headers.get("range") : null;
       if (range && enableRanges) {
         return FileStreamHandler.handleRangeRequest(file, range, contentType);
       }
@@ -4272,8 +4293,8 @@ class FileStreamHandler {
 function registerFileStreaming(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     streamFile: {
-      value(filePath, request, options) {
-        return FileStreamHandler.streamFile(filePath, request, options);
+      value(filePath, request2, options) {
+        return FileStreamHandler.streamFile(filePath, request2, options);
       },
       writable: true,
       configurable: true
@@ -5627,6 +5648,60 @@ var SubdomainPatterns = {
   environment: (domain) => `{env}.${domain}`
 };
 
+// src/url.ts
+import process3 from "process";
+var namedRouteRegistry = new Map;
+function registerNamedRoute(name, path) {
+  namedRouteRegistry.set(name, path);
+}
+function getNamedRoutePath(name) {
+  return namedRouteRegistry.get(name);
+}
+function getNamedRoutes() {
+  return new Map(namedRouteRegistry);
+}
+function clearNamedRoutes() {
+  namedRouteRegistry.clear();
+}
+function url(name, params = {}, options = {}) {
+  const path = namedRouteRegistry.get(name);
+  if (!path) {
+    const known = [...namedRouteRegistry.keys()].sort().join(", ") || "(none registered)";
+    throw new Error(`Named route '${name}' is not defined. Known routes: ${known}`);
+  }
+  const consumed = new Set;
+  let resolved = path;
+  for (const [key, value] of Object.entries(params)) {
+    const required = `{${key}}`;
+    const optional = `{${key}?}`;
+    const encoded = encodeURIComponent(String(value));
+    if (resolved.includes(required)) {
+      resolved = resolved.replaceAll(required, encoded);
+      consumed.add(key);
+    } else if (resolved.includes(optional)) {
+      resolved = resolved.replaceAll(optional, encoded);
+      consumed.add(key);
+    }
+  }
+  resolved = resolved.replace(/\/\{[^}]+\?\}/g, "");
+  const missing = resolved.match(/\{([^}?]+)\}/g);
+  if (missing && missing.length > 0)
+    throw new Error(`Missing required params for route '${name}': ${missing.join(", ")}`);
+  const leftover = Object.entries(params).filter(([k]) => !consumed.has(k));
+  if (leftover.length > 0) {
+    const qs = new URLSearchParams;
+    for (const [k, v] of leftover)
+      qs.set(k, String(v));
+    resolved += `?${qs.toString()}`;
+  }
+  if (options.absolute) {
+    const base = (options.base ?? process3.env.APP_URL ?? "http://localhost").replace(/\/$/, "");
+    const prefixed = base.startsWith("http") ? base : `https://${base}`;
+    return `${prefixed}${resolved.startsWith("/") ? resolved : `/${resolved}`}`;
+  }
+  return resolved;
+}
+
 // src/router/fluent-routing.ts
 class FluentRouteBuilder {
   method;
@@ -5880,6 +5955,8 @@ class FluentRouter {
   register(builder) {
     const route = builder.build();
     this.routes.push(route);
+    if (route.name)
+      registerNamedRoute(route.name, route.path);
     return this;
   }
   cached(tags = [], config2) {
@@ -5920,6 +5997,8 @@ class FluentRouter {
         this.subdomainRouter.addDomainGroup(domainGroup);
       } else {
         this.routes.push(groupedRoute);
+        if (groupedRoute.name)
+          registerNamedRoute(groupedRoute.name, groupedRoute.path);
       }
     }
     return this;
@@ -5965,45 +6044,45 @@ class FluentRouter {
   getRoutes() {
     return [...this.routes, ...this.subdomainRouter.getAllRoutes()];
   }
-  async handle(request) {
-    const _url = new URL(request.url);
-    const url = new URL(request.url);
-    const domain = url.hostname;
+  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);
     if (match) {
-      const enhancedReq = request;
+      const enhancedReq = request2;
       enhancedReq.domainParams = match.parameters;
       for (const route of match.group.getRoutes()) {
-        if (this.matchesRoute(route, request)) {
+        if (this.matchesRoute(route, request2)) {
           return await this.executeRoute(route, enhancedReq);
         }
       }
     }
     for (const route of this.routes) {
-      if (this.matchesRoute(route, request)) {
-        return await this.executeRoute(route, request);
+      if (this.matchesRoute(route, request2)) {
+        return await this.executeRoute(route, request2);
       }
     }
     return null;
   }
-  matchesRoute(route, request) {
-    if (route.method !== request.method) {
+  matchesRoute(route, request2) {
+    if (route.method !== request2.method) {
       return false;
     }
-    const url = new URL(request.url);
+    const url2 = new URL(request2.url);
     const routePattern = route.path.replace(/\{([^:}]+):?([^}]*)\}/g, "([^/]+)");
     const regex = new RegExp(`^${routePattern}$`);
-    return regex.test(url.pathname);
+    return regex.test(url2.pathname);
   }
-  async executeRoute(route, request) {
+  async executeRoute(route, request2) {
     const allMiddleware = [...this.globalMiddleware, ...route.middleware];
     let index = 0;
     const next = async () => {
       if (index < allMiddleware.length) {
         const middleware2 = allMiddleware[index++];
-        return await middleware2(request, next);
+        return await middleware2(request2, next);
       }
-      return await route.handler(request);
+      return await route.handler(request2);
     };
     return await next();
   }
@@ -6041,20 +6120,20 @@ var RouteFactory = {
 };
 var RouterUtils = {
   route: (name, params = {}, query = {}) => {
-    let url = `/${name}`;
+    let url2 = `/${name}`;
     for (const [key, value] of Object.entries(params)) {
-      url = url.replace(`{${key}}`, value);
+      url2 = url2.replace(`{${key}}`, value);
     }
     const queryString = new URLSearchParams(query).toString();
     if (queryString) {
-      url += `?${queryString}`;
+      url2 += `?${queryString}`;
     }
-    return url;
+    return url2;
   },
-  redirect: (url, status = 302) => {
+  redirect: (url2, status = 302) => {
     return new Response(null, {
       status,
-      headers: { Location: url }
+      headers: { Location: url2 }
     });
   },
   json: (data, status = 200) => {
@@ -6408,10 +6487,10 @@ function registerHttpMethods(RouterClass) {
           route.constraints = constraints;
         }
         route.pattern = {
-          exec: (url) => {
+          exec: (url2) => {
             const params = {};
             const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-            const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
+            const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
             if (!isMatch) {
               return null;
             }
@@ -6445,6 +6524,7 @@ function registerHttpMethods(RouterClass) {
         if (name) {
           route.name = name;
           this.namedRoutes.set(name, route);
+          registerNamedRoute(name, route.path);
         }
         if (this.addRouteToCompiler) {
           this.addRouteToCompiler(route);
@@ -6529,12 +6609,12 @@ function registerHttpMethods(RouterClass) {
         if (!route) {
           throw new Error(`Route with name "${name}" not found`);
         }
-        let url = route.path;
+        let url2 = route.path;
         for (const [param, value] of Object.entries(params)) {
-          url = url.replace(`{${param}}`, encodeURIComponent(value));
-          url = url.replace(`{${param}?}`, encodeURIComponent(value));
+          url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
+          url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
         }
-        return url;
+        return url2;
       },
       writable: true,
       configurable: true
@@ -6552,9 +6632,9 @@ function registerHttpMethods(RouterClass) {
 function registerRedirectMethods(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     redirect: {
-      value(url, status = 302) {
+      value(url2, status = 302) {
         const headers = new Headers;
-        headers.set("Location", url);
+        headers.set("Location", url2);
         return new Response(null, {
           status,
           headers
@@ -6564,8 +6644,8 @@ function registerRedirectMethods(RouterClass) {
       configurable: true
     },
     permanentRedirect: {
-      value(url) {
-        return this.redirect(url, 301);
+      value(url2) {
+        return this.redirect(url2, 301);
       },
       writable: true,
       configurable: true
@@ -7560,8 +7640,8 @@ class RouteCompiler {
       }
       const pattern = this.convertToURLPattern(route.path, route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined);
       const urlPatternAdapter = {
-        exec: (url) => {
-          const pathname = url.pathname;
+        exec: (url2) => {
+          const pathname = url2.pathname;
           const result = pattern.exec(pathname);
           if (!result)
             return null;
@@ -7920,13 +8000,13 @@ function registerOptimizedRouteMatching(RouterClass) {
     },
     fallbackMatchRoute: {
       value(path, method, domain) {
-        const url = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+        const url2 = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -7939,7 +8019,7 @@ function registerOptimizedRouteMatching(RouterClass) {
         const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
         const methodRoutes = potentialRoutes.filter((route) => route.method === method);
         for (const route of methodRoutes) {
-          if (route.path === url.pathname) {
+          if (route.path === url2.pathname) {
             const result = {
               route,
               params: {}
@@ -7950,7 +8030,7 @@ function registerOptimizedRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url);
+            const match = route.pattern.exec(url2);
             if (match) {
               const result = {
                 route,
@@ -8075,10 +8155,10 @@ function registerRouteBuilding(RouterClass) {
               } catch {}
             }
             bunRoutes[path] = async (req) => {
-              const url = new URL(req.url);
+              const url2 = new URL(req.url);
               const params = {};
               const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-              matchPath(path, url.pathname, params, constraintsRecord);
+              matchPath(path, url2.pathname, params, constraintsRecord);
               const enhancedReq = this.enhanceRequest(req, params);
               const middlewareResult = await this.runMiddleware(enhancedReq, [...this.globalMiddleware, ...route.middleware]);
               if (middlewareResult) {
@@ -8092,10 +8172,10 @@ function registerRouteBuilding(RouterClass) {
             for (const route of routes) {
               const method = route.method;
               methodHandlers[method] = async (req) => {
-                const url = new URL(req.url);
+                const url2 = new URL(req.url);
                 const params = {};
                 const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-                matchPath(path, url.pathname, params, constraintsRecord);
+                matchPath(path, url2.pathname, params, constraintsRecord);
                 const enhancedReq = this.enhanceRequest(req, params);
                 const middlewareResult = await this.runMiddleware(enhancedReq, [...this.globalMiddleware, ...route.middleware]);
                 if (middlewareResult) {
@@ -8191,13 +8271,13 @@ function registerRouteMatching(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     matchRoute: {
       value(path, method, domain) {
-        const url = new URL(path, "http://localhost");
-        const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+        const url2 = new URL(path, "http://localhost");
+        const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
         if (this.routeCache.has(cacheKey)) {
           return this.routeCache.get(cacheKey);
         }
         if (this.staticRoutes.has(method)) {
-          const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+          const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
           if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
             const result = {
               route: staticRoute,
@@ -8210,7 +8290,7 @@ function registerRouteMatching(RouterClass) {
         const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
         const methodRoutes = potentialRoutes.filter((route) => route.method === method);
         for (const route of methodRoutes) {
-          if (route.path === url.pathname) {
+          if (route.path === url2.pathname) {
             const result = {
               route,
               params: {}
@@ -8221,7 +8301,7 @@ function registerRouteMatching(RouterClass) {
         }
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url);
+            const match = route.pattern.exec(url2);
             if (match) {
               const result = {
                 route,
@@ -8236,11 +8316,11 @@ function registerRouteMatching(RouterClass) {
           const wildcardRoutes = this.domains[domain].filter((route) => route.method === method && route.path.endsWith("*"));
           for (const route of wildcardRoutes) {
             const basePath = route.path.slice(0, -1);
-            if (url.pathname.startsWith(basePath)) {
+            if (url2.pathname.startsWith(basePath)) {
               const result = {
                 route,
                 params: {
-                  wildcard: url.pathname.slice(basePath.length)
+                  wildcard: url2.pathname.slice(basePath.length)
                 }
               };
               this.routeCache.set(cacheKey, result);
@@ -8251,11 +8331,11 @@ function registerRouteMatching(RouterClass) {
         const globalWildcardRoutes = this.routes.filter((route) => route.method === method && route.path.endsWith("*") && (!domain || !route.domain));
         for (const route of globalWildcardRoutes) {
           const basePath = route.path.slice(0, -1);
-          if (url.pathname.startsWith(basePath)) {
+          if (url2.pathname.startsWith(basePath)) {
             const result = {
               route,
               params: {
-                wildcard: url.pathname.slice(basePath.length)
+                wildcard: url2.pathname.slice(basePath.length)
               }
             };
             this.routeCache.set(cacheKey, result);
@@ -8356,9 +8436,9 @@ function registerRouteMatching(RouterClass) {
           const routePath = lastRoute.path;
           const constraintsRecord = lastRoute.constraints && !Array.isArray(lastRoute.constraints) ? lastRoute.constraints : undefined;
           lastRoute.pattern = {
-            exec: (url) => {
+            exec: (url2) => {
               const params2 = {};
-              const isMatch = matchPath(routePath, url.pathname, params2, constraintsRecord);
+              const isMatch = matchPath(routePath, url2.pathname, params2, constraintsRecord);
               if (!isMatch) {
                 return null;
               }
@@ -8595,10 +8675,10 @@ class Router {
       route.constraints = constraints;
     }
     route.pattern = {
-      exec: (url) => {
+      exec: (url2) => {
         const params = {};
         const constraintsRecord = route.constraints && !Array.isArray(route.constraints) ? route.constraints : undefined;
-        const isMatch = matchPath(routePath, url.pathname, params, constraintsRecord);
+        const isMatch = matchPath(routePath, url2.pathname, params, constraintsRecord);
         if (!isMatch) {
           return null;
         }
@@ -8626,6 +8706,7 @@ class Router {
     if (name) {
       route.name = name;
       this.namedRoutes.set(name, route);
+      registerNamedRoute(name, route.path);
     }
     this.routeCache.clear();
     return this;
@@ -8678,27 +8759,27 @@ class Router {
     if (!route) {
       throw new Error(`Route with name "${name}" not found`);
     }
-    let url = route.path;
+    let url2 = route.path;
     for (const [param, value] of Object.entries(params)) {
-      url = url.replace(`{${param}}`, encodeURIComponent(value));
-      url = url.replace(`{${param}?}`, encodeURIComponent(value));
+      url2 = url2.replace(`{${param}}`, encodeURIComponent(value));
+      url2 = url2.replace(`{${param}?}`, encodeURIComponent(value));
     }
-    return url;
+    return url2;
   }
   onError(handler) {
     this.errorHandler = handler;
     return this;
   }
-  redirect(url, status = 302) {
+  redirect(url2, status = 302) {
     const headers = new Headers;
-    headers.set("Location", url);
+    headers.set("Location", url2);
     return new Response(null, {
       status,
       headers
     });
   }
-  permanentRedirect(url) {
-    return this.redirect(url, 301);
+  permanentRedirect(url2) {
+    return this.redirect(url2, 301);
   }
   redirectRoute(from, to, status = 302) {
     this.get(from, (_req) => {
@@ -8725,13 +8806,13 @@ class Router {
   }
   async handleRequest(req) {
     try {
-      const url = new URL(req.url);
+      const url2 = new URL(req.url);
       if (this.config.verbose) {
-        console.log(`${req.method} ${url.pathname}`);
+        console.log(`${req.method} ${url2.pathname}`);
       }
       if (req.method === "OPTIONS") {
-        const hostname2 = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-        const optionsMatch = this.matchRoute(url.pathname, "OPTIONS", hostname2);
+        const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+        const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
         if (!optionsMatch) {
           return new Response(null, {
             status: 204,
@@ -8744,8 +8825,8 @@ class Router {
           });
         }
       }
-      const hostname = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-      const match = this.matchRoute(url.pathname, req.method, hostname);
+      const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+      const match = this.matchRoute(url2.pathname, req.method, hostname);
       const enhancedReq = this.enhanceRequest(req, match?.params || {});
       if (match) {
         enhancedReq.route = match.route;
@@ -8763,10 +8844,15 @@ class Router {
         }
         return new Response("No response from middleware chain", { status: 500 });
       }
-      const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
+      const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
       if (allowedMethods.length > 0) {
         const methodNotAllowedHandler = async (_req, _next) => {
-          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          return new Response(JSON.stringify({
+            error: "Method Not Allowed",
+            path: url2.pathname,
+            method: req.method,
+            allowed: allowedMethods
+          }), {
             status: 405,
             headers: {
               "Content-Type": "application/json",
@@ -8788,7 +8874,11 @@ class Router {
           if (this.fallbackHandler) {
             return await this.resolveHandler(this.fallbackHandler, enhancedReq);
           }
-          return new Response(JSON.stringify({ error: "Not Found" }), {
+          return new Response(JSON.stringify({
+            error: "Not Found",
+            path: url2.pathname,
+            method: req.method
+          }), {
             status: 404,
             headers: { "Content-Type": "application/json" }
           });
@@ -8803,7 +8893,11 @@ class Router {
         const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
         return this.applyModifiedCookies(response2, enhancedReq);
       }
-      return new Response(JSON.stringify({ error: "Not Found" }), {
+      return new Response(JSON.stringify({
+        error: "Not Found",
+        path: url2.pathname,
+        method: req.method
+      }), {
         status: 404,
         headers: { "Content-Type": "application/json" }
       });
@@ -8844,12 +8938,12 @@ class Router {
     }
   }
   getAllowedMethods(path, domain) {
-    const url = new URL(path, "http://localhost");
+    const url2 = new URL(path, "http://localhost");
     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(url.pathname);
+        const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
         if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
           methods.add(method);
           continue;
@@ -8858,7 +8952,7 @@ class Router {
       const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
       const methodRoutes = potentialRoutes.filter((route) => route.method === method);
       for (const route of methodRoutes) {
-        if (route.path === url.pathname) {
+        if (route.path === url2.pathname) {
           methods.add(method);
           break;
         }
@@ -8866,7 +8960,7 @@ class Router {
       if (!methods.has(method)) {
         for (const route of methodRoutes) {
           if (route.pattern) {
-            const match = route.pattern.exec(url);
+            const match = route.pattern.exec(url2);
             if (match) {
               methods.add(method);
               break;
@@ -8878,7 +8972,7 @@ class Router {
         const wildcardRoutes = potentialRoutes.filter((route) => route.method === method && route.path.endsWith("*"));
         for (const route of wildcardRoutes) {
           const basePath = route.path.slice(0, -1);
-          if (url.pathname.startsWith(basePath)) {
+          if (url2.pathname.startsWith(basePath)) {
             methods.add(method);
             break;
           }
@@ -8891,13 +8985,13 @@ class Router {
     return Array.from(methods);
   }
   matchRoute(path, method, domain) {
-    const url = new URL(path, "http://localhost");
-    const cacheKey = `${domain || ""}:${method}:${url.pathname}`;
+    const url2 = new URL(path, "http://localhost");
+    const cacheKey = `${domain || ""}:${method}:${url2.pathname}`;
     if (this.routeCache.has(cacheKey)) {
       return this.routeCache.get(cacheKey);
     }
     if (this.staticRoutes.has(method)) {
-      const staticRoute = this.staticRoutes.get(method).get(url.pathname);
+      const staticRoute = this.staticRoutes.get(method).get(url2.pathname);
       if (staticRoute && (!domain || !staticRoute.domain || staticRoute.domain === domain)) {
         const result = {
           route: staticRoute,
@@ -8910,7 +9004,7 @@ class Router {
     const potentialRoutes = domain && this.domains[domain] ? this.domains[domain] : this.routes;
     const methodRoutes = potentialRoutes.filter((route) => route.method === method);
     for (const route of methodRoutes) {
-      if (route.path === url.pathname) {
+      if (route.path === url2.pathname) {
         const result = {
           route,
           params: {}
@@ -8921,7 +9015,7 @@ class Router {
     }
     for (const route of methodRoutes) {
       if (route.pattern) {
-        const match = route.pattern.exec(url);
+        const match = route.pattern.exec(url2);
         if (match) {
           const result = {
             route,
@@ -8936,11 +9030,11 @@ class Router {
       const wildcardRoutes = this.domains[domain].filter((route) => route.method === method && route.path.endsWith("*"));
       for (const route of wildcardRoutes) {
         const basePath = route.path.slice(0, -1);
-        if (url.pathname.startsWith(basePath)) {
+        if (url2.pathname.startsWith(basePath)) {
           const result = {
             route,
             params: {
-              wildcard: url.pathname.slice(basePath.length)
+              wildcard: url2.pathname.slice(basePath.length)
             }
           };
           this.routeCache.set(cacheKey, result);
@@ -8951,11 +9045,11 @@ class Router {
     const globalWildcardRoutes = this.routes.filter((route) => route.method === method && route.path.endsWith("*") && (!domain || !route.domain));
     for (const route of globalWildcardRoutes) {
       const basePath = route.path.slice(0, -1);
-      if (url.pathname.startsWith(basePath)) {
+      if (url2.pathname.startsWith(basePath)) {
         const result = {
           route,
           params: {
-            wildcard: url.pathname.slice(basePath.length)
+            wildcard: url2.pathname.slice(basePath.length)
           }
         };
         this.routeCache.set(cacheKey, result);
@@ -8984,9 +9078,9 @@ class Router {
       }
       return parsedCookies;
     };
-    const url = new URL(req.url);
+    const url2 = new URL(req.url);
     const query = {};
-    url.searchParams.forEach((value, key) => {
+    url2.searchParams.forEach((value, key) => {
       query[key] = value;
     });
     const enhancedReq = {
@@ -9173,6 +9267,20 @@ class Router {
         return value;
       return value !== undefined && value !== null ? [value] : [];
     };
+    enhancedReq.bearerToken = () => {
+      const authHeader = req.headers.get("authorization") || req.headers.get("Authorization") || "";
+      if (authHeader.startsWith("Bearer "))
+        return authHeader.substring(7);
+      return null;
+    };
+    enhancedReq.header = (name) => {
+      return req.headers.get(name) || req.headers.get(name.toLowerCase()) || null;
+    };
+    enhancedReq.getParam = (name, defaultValue) => {
+      const value = params?.[name];
+      return value !== undefined ? value : defaultValue;
+    };
+    enhancedReq.params = params || {};
     return enhancedReq;
   }
   applyModifiedCookies(response2, req) {
@@ -9310,6 +9418,7 @@ class Router {
     this.routes.push(route);
     if (route.name) {
       this.namedRoutes.set(route.name, route);
+      registerNamedRoute(route.name, route.path);
     }
     return this;
   }
@@ -9341,7 +9450,7 @@ class Router {
     }
     return this;
   }
-  async executeMiddleware(middleware2, request, handler) {
+  async executeMiddleware(middleware2, request2, handler) {
     if (middleware2.length === 0) {
       return handler();
     }
@@ -9351,7 +9460,7 @@ class Router {
         return handler();
       }
       const mw = middleware2[currentIndex++];
-      const result = await mw(request, next);
+      const result = await mw(request2, next);
       return result || new Response("No response from middleware", { status: 500 });
     };
     return next();
@@ -9493,12 +9602,20 @@ function registerServerHandling(RouterClass) {
       configurable: true
     },
     handleRequest: {
+      async value(req) {
+        const self = this;
+        return runWithRequest(req, () => self.handleRequestImpl(req));
+      },
+      writable: true,
+      configurable: true
+    },
+    handleRequestImpl: {
       async value(req) {
         try {
-          const url = new URL(req.url);
+          const url2 = new URL(req.url);
           if (req.method === "OPTIONS") {
-            const hostname2 = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-            const optionsMatch = this.matchRoute(url.pathname, "OPTIONS", hostname2);
+            const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+            const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
             if (!optionsMatch) {
               return new Response(null, {
                 status: 204,
@@ -9512,9 +9629,10 @@ function registerServerHandling(RouterClass) {
               });
             }
           }
-          const hostname = url.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-          const match = this.matchRoute(url.pathname, req.method, hostname);
+          const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+          const match = this.matchRoute(url2.pathname, req.method, hostname);
           const enhancedReq = this.enhanceRequest(req, match?.params || {});
+          setCurrentRequest(enhancedReq);
           if (match) {
             enhancedReq.route = match.route;
             const middlewareStack = [...this.globalMiddleware];
@@ -9531,32 +9649,53 @@ function registerServerHandling(RouterClass) {
             }
             return new Response("No response from middleware chain", { status: 500 });
           }
-          const allowedMethods = this.getAllowedMethods(url.pathname, hostname);
+          const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
+          const corsHeaders = {
+            "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"
+          };
           if (allowedMethods.length > 0) {
-            return new Response(JSON.stringify({ success: false, message: "Method Not Allowed" }), {
-              status: 405,
-              headers: {
-                "Content-Type": "application/json",
-                Allow: allowedMethods.join(", "),
-                "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 methodNotAllowedHandler = async (_req, _next) => {
+              return new Response(JSON.stringify({
+                success: false,
+                message: "Method Not Allowed",
+                path: url2.pathname,
+                method: req.method,
+                allowed: allowedMethods
+              }), {
+                status: 405,
+                headers: { ...corsHeaders, Allow: allowedMethods.join(", ") }
+              });
+            };
+            if (this.globalMiddleware.length > 0) {
+              const stack = [...this.globalMiddleware, methodNotAllowedHandler];
+              const response2 = await this.runMiddleware(enhancedReq, stack);
+              if (response2)
+                return this.applyModifiedCookies(response2, enhancedReq);
+            }
+            return await methodNotAllowedHandler(enhancedReq, async () => null);
           }
           if (this.fallbackHandler) {
             const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
             return this.applyModifiedCookies(response2, enhancedReq);
           }
-          return new Response(JSON.stringify({ success: false, message: "Not Found" }), {
-            status: 404,
-            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 notFoundHandler = async (_req, _next) => {
+            return new Response(JSON.stringify({
+              success: false,
+              message: "Not Found",
+              path: url2.pathname,
+              method: req.method
+            }), { status: 404, headers: corsHeaders });
+          };
+          if (this.globalMiddleware.length > 0) {
+            const stack = [...this.globalMiddleware, notFoundHandler];
+            const response2 = await this.runMiddleware(enhancedReq, stack);
+            if (response2)
+              return this.applyModifiedCookies(response2, enhancedReq);
+          }
+          return await notFoundHandler(enhancedReq, async () => null);
         } catch (error) {
           console.error("Error handling request:", error);
           if (this.errorHandler) {
@@ -9865,34 +10004,34 @@ function registerWebSocketHandling(RouterClass) {
       configurable: true
     },
     upgrade: {
-      value(request, options) {
+      value(request2, options) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot upgrade to WebSocket");
         }
         if (!this.wsConfig) {
           throw new Error("WebSocket configuration not set, use router.websocket() to configure");
         }
-        return this.serverInstance.upgrade(request, options);
+        return this.serverInstance.upgrade(request2, options);
       },
       writable: true,
       configurable: true
     },
     timeout: {
-      value(request, seconds) {
+      value(request2, seconds) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot set timeout");
         }
-        this.serverInstance.timeout(request, seconds);
+        this.serverInstance.timeout(request2, seconds);
       },
       writable: true,
       configurable: true
     },
     requestIP: {
-      value(request) {
+      value(request2) {
         if (!this.serverInstance) {
           throw new Error("Server not started, cannot get request IP");
         }
-        return this.serverInstance.requestIP(request);
+        return this.serverInstance.requestIP(request2);
       },
       writable: true,
       configurable: true
@@ -9927,12 +10066,12 @@ class RequestWithMacros {
   static macro(name, handler) {
     requestMacroRegistry.register(name, handler);
   }
-  static applyMacros(request) {
+  static applyMacros(request2) {
     const macros = requestMacroRegistry.all();
     macros.forEach((macro) => {
-      request[macro.name] = macro.handler.bind(request);
+      request2[macro.name] = macro.handler.bind(request2);
     });
-    return request;
+    return request2;
   }
   static hasMacro(name) {
     return requestMacroRegistry.has(name);
@@ -10138,8 +10277,8 @@ var BuiltInRequestMacros = {
     return this.url;
   },
   root() {
-    const url = new URL(this.url);
-    return `${url.protocol}//${url.host}`;
+    const url2 = new URL(this.url);
+    return `${url2.protocol}//${url2.host}`;
   },
   is(pattern) {
     const path = this.path();
@@ -10151,11 +10290,11 @@ var BuiltInRequestMacros = {
     return this.routeName || null;
   },
   fingerprint() {
-    const url = new URL(this.url);
+    const url2 = new URL(this.url);
     const data = {
       method: this.method,
-      path: url.pathname,
-      query: url.search,
+      path: url2.pathname,
+      query: url2.search,
       ip: BuiltInRequestMacros.ip.call(this)
     };
     return btoa(JSON.stringify(data));
@@ -10207,7 +10346,7 @@ function registerBuiltInRequestMacros() {
 registerBuiltInRequestMacros();
 
 // src/response/macros.ts
-import process3 from "process";
+import process4 from "process";
 
 class ResponseMacroRegistry {
   macros = new Map;
@@ -10361,16 +10500,16 @@ var BuiltInResponseMacros = {
       }
     });
   },
-  redirect: (url, status = 302) => {
+  redirect: (url2, status = 302) => {
     return new Response(null, {
       status,
       headers: {
-        Location: url
+        Location: url2
       }
     });
   },
-  permanentRedirect: (url) => {
-    return BuiltInResponseMacros.redirect(url, 301);
+  permanentRedirect: (url2) => {
+    return BuiltInResponseMacros.redirect(url2, 301);
   },
   download: (data, filename, contentType = "application/octet-stream") => {
     return new Response(data, {
@@ -10441,7 +10580,7 @@ var BuiltInResponseMacros = {
       status,
       timestamp: new Date().toISOString(),
       checks,
-      uptime: process3.uptime?.() || 0
+      uptime: process4.uptime?.() || 0
     };
     return new Response(JSON.stringify(response2), {
       status: statusCode,
@@ -10507,8 +10646,8 @@ var BuiltInRules = {
     name: "url",
     validate: (value) => {
       try {
-        const url = new URL(value);
-        return Boolean(url);
+        const url2 = new URL(value);
+        return Boolean(url2);
       } catch {
         return false;
       }
@@ -11332,8 +11471,8 @@ function createCookieAccessor2(cookies) {
 
 class AuthTester {
   request;
-  constructor(request) {
-    this.request = request || createMockRequest();
+  constructor(request2) {
+    this.request = request2 || createMockRequest();
   }
   as(user) {
     this.request.user = user;
@@ -11561,16 +11700,16 @@ var authMocks = {
   })
 };
 var authHelpers = {
-  authenticatedRequest: (user, request) => {
-    return new AuthTester(request).as(user).getRequest();
+  authenticatedRequest: (user, request2) => {
+    return new AuthTester(request2).as(user).getRequest();
   },
-  jwtRequest: (payload = {}, request) => {
+  jwtRequest: (payload = {}, request2) => {
     const jwt = new JWTTester;
     const token = jwt.generateToken(payload);
-    return new AuthTester(request).withJWT(token).getRequest();
+    return new AuthTester(request2).withJWT(token).getRequest();
   },
-  sessionRequest: (sessionData = {}, request) => {
-    return new AuthTester(request).withSession(sessionData).getRequest();
+  sessionRequest: (sessionData = {}, request2) => {
+    return new AuthTester(request2).withSession(sessionData).getRequest();
   },
   verifyJWTStructure: (token) => {
     const parts = token.split(".");
@@ -11585,8 +11724,8 @@ var authHelpers = {
     }
   }
 };
-function createAuthTester(request) {
-  return new AuthTester(request);
+function createAuthTester(request2) {
+  return new AuthTester(request2);
 }
 function createJWTTester(options) {
   return new JWTTester(options);
@@ -11599,8 +11738,8 @@ import { mock as mock2 } from "bun:test";
 class FileUploadTester {
   request;
   files;
-  constructor(request) {
-    this.request = request || createMockRequest();
+  constructor(request2) {
+    this.request = request2 || createMockRequest();
     this.files = [];
   }
   addFile(testFile) {
@@ -11832,8 +11971,8 @@ var fileUploadScenarios = {
   }
 };
 var fileUploadAssertions = {
-  hasFiles: (request, count) => {
-    const files = request.files || [];
+  hasFiles: (request2, count) => {
+    const files = request2.files || [];
     if (count !== undefined && files.length !== count) {
       throw new Error(`Expected ${count} files, but got ${files.length}`);
     }
@@ -11841,8 +11980,8 @@ var fileUploadAssertions = {
       throw new Error("Expected request to have files");
     }
   },
-  hasFileWithField: (request, fieldName) => {
-    const files = request.files || [];
+  hasFileWithField: (request2, fieldName) => {
+    const files = request2.files || [];
     const hasField = files.some((file) => file.fieldName === fieldName);
     if (!hasField) {
       throw new Error(`Expected file with field name '${fieldName}'`);
@@ -11866,8 +12005,8 @@ var fileUploadAssertions = {
     }
   }
 };
-function createFileUploadTester(request) {
-  return new FileUploadTester(request);
+function createFileUploadTester(request2) {
+  return new FileUploadTester(request2);
 }
 var testFiles = {
   image: (fieldName = "image", filename = "test.jpg") => ({
@@ -11911,15 +12050,15 @@ class MiddlewareTester {
     this.context = this.createContext();
   }
   createContext() {
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     const next = mock3(() => Promise.resolve(new Response("Next called", { status: 200 })));
     return {
-      request,
+      request: request2,
       next
     };
   }
-  withRequest(request) {
-    this.context.request = request;
+  withRequest(request2) {
+    this.context.request = request2;
     return this;
   }
   withNext(nextFn) {
@@ -12017,8 +12156,8 @@ class MiddlewareChainTester {
     this.request = createMockRequest();
     this.finalHandler = mock3(async () => new Response("Final handler", { status: 200 }));
   }
-  withRequest(request) {
-    this.request = request;
+  withRequest(request2) {
+    this.request = request2;
     return this;
   }
   withFinalHandler(handler) {
@@ -12058,11 +12197,11 @@ function createMiddlewareSpy() {
 }
 async function benchmarkMiddleware(middleware2, iterations = 1000) {
   const times = [];
-  const request = createMockRequest();
+  const request2 = createMockRequest();
   const next = mock3(async () => new Response("OK"));
   for (let i = 0;i < iterations; i++) {
     const start = performance.now();
-    await middleware2(request, next);
+    await middleware2(request2, next);
     const end = performance.now();
     times.push(end - start);
   }
@@ -12160,8 +12299,8 @@ class ModelBindingTester {
     this.options = options;
     this.request = createMockRequest();
   }
-  withRequest(request) {
-    this.request = request;
+  withRequest(request2) {
+    this.request = request2;
     return this;
   }
   withParams(params) {
@@ -12299,18 +12438,18 @@ var modelMocks = {
 };
 var constraintHelpers = {
   belongsTo: (userIdField = "userId") => {
-    const fn = async (model, request) => {
-      if (!request.user)
+    const fn = async (model, request2) => {
+      if (!request2.user)
         return false;
-      return model[userIdField] === request.user.id;
+      return model[userIdField] === request2.user.id;
     };
     return mock4(fn);
   },
   belongsToUser: () => {
-    const fn = async (model, request) => {
-      if (!request.user)
+    const fn = async (model, request2) => {
+      if (!request2.user)
         return false;
-      return model.userId === request.user.id;
+      return model.userId === request2.user.id;
     };
     return mock4(fn);
   },
@@ -12330,9 +12469,9 @@ var constraintHelpers = {
     return mock4(constraintFn);
   },
   combine: (...constraints) => {
-    const fn = async (model, request) => {
+    const fn = async (model, request2) => {
       for (const constraint of constraints) {
-        if (!await constraint(model, request)) {
+        if (!await constraint(model, request2)) {
           return false;
         }
       }
@@ -12389,24 +12528,24 @@ class ModelResolverTester {
 }
 var routeModelHelpers = {
   testRoute: async (path, params, modelBindings) => {
-    const request = createMockRequest("GET", path);
-    request.params = params;
+    const request2 = createMockRequest("GET", path);
+    request2.params = params;
     for (const [key, model] of Object.entries(modelBindings)) {
-      request.context = request.context || {};
-      request.context[key] = model;
+      request2.context = request2.context || {};
+      request2.context[key] = model;
     }
-    return request;
+    return request2;
   },
   createHandler: (expectedModels) => {
-    const fn = async (request) => {
-      const context = request.context || {};
+    const fn = async (request2) => {
+      const context = request2.context || {};
       for (const modelKey of expectedModels) {
         if (!context[modelKey]) {
           return new Response(`Model ${modelKey} not found`, { status: 404 });
         }
       }
       return new Response(JSON.stringify({
-        params: request.params,
+        params: request2.params,
         models: Object.fromEntries(expectedModels.map((key) => [key, context[key]]))
       }), {
         headers: { "Content-Type": "application/json" }
@@ -12415,16 +12554,16 @@ var routeModelHelpers = {
     return mock4(fn);
   },
   testBindingMiddleware: (bindings) => {
-    const fn = async (request, next) => {
-      request.context = request.context || {};
+    const fn = async (request2, next) => {
+      request2.context = request2.context || {};
       for (const [key, resolver] of Object.entries(bindings)) {
-        const paramValue = request.params[key];
+        const paramValue = request2.params[key];
         if (paramValue) {
           try {
             if (typeof resolver === "function") {
-              request.context[key] = await resolver(paramValue);
+              request2.context[key] = await resolver(paramValue);
             } else {
-              request.context[key] = resolver;
+              request2.context[key] = resolver;
             }
           } catch (error) {
             console.error(`Error resolving model ${key}:`, error);
@@ -12461,7 +12600,7 @@ var scopedBindingHelpers = {
 };
 // src/testing/performance-testing.ts
 import { mock as mock5 } from "bun:test";
-import process4 from "process";
+import process5 from "process";
 class PerformanceTester {
   metrics = [];
   startTime = 0;
@@ -12580,10 +12719,10 @@ class LoadTester {
 var benchmarkTests = {
   routeHandler: async (handler, iterations = 1000) => {
     const times = [];
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await handler(request);
+      await handler(request2);
       const end = performance.now();
       times.push(end - start);
     }
@@ -12602,11 +12741,11 @@ var benchmarkTests = {
   },
   middleware: async (middleware2, iterations = 1000) => {
     const times = [];
-    const request = createMockRequest();
+    const request2 = createMockRequest();
     const next = mock5(async () => new Response("OK"));
     for (let i = 0;i < iterations; i++) {
       const start = performance.now();
-      await middleware2(request, next);
+      await middleware2(request2, next);
       const end = performance.now();
       times.push(end - start);
     }
@@ -12679,11 +12818,11 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const initialHeap = process4.memoryUsage().heapUsed;
+    const initialHeap = process5.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
       const result = await fn();
       results.push(result);
-      const memUsage = process4.memoryUsage();
+      const memUsage = process5.memoryUsage();
       heapUsages.push(memUsage.heapUsed);
       if (i % 10 === 0 && globalThis.gc) {
         globalThis.gc();
@@ -12692,7 +12831,7 @@ var memoryTests = {
     if (globalThis.gc) {
       globalThis.gc();
     }
-    const finalHeap = process4.memoryUsage().heapUsed;
+    const finalHeap = process5.memoryUsage().heapUsed;
     const averageHeapUsed = heapUsages.reduce((sum, usage) => sum + usage, 0) / heapUsages.length;
     const maxHeapUsed = Math.max(...heapUsages);
     const memoryLeakDetected = finalHeap - initialHeap > 1024 * 1024;
@@ -12706,17 +12845,17 @@ var memoryTests = {
   testRouteHandlerMemoryLeaks: async (handler, iterations = 1000) => {
     if (globalThis.gc)
       globalThis.gc();
-    const initialMemory = process4.memoryUsage().heapUsed;
+    const initialMemory = process5.memoryUsage().heapUsed;
     for (let i = 0;i < iterations; i++) {
-      const request = createMockRequest();
-      await handler(request);
+      const request2 = createMockRequest();
+      await handler(request2);
       if (i % 100 === 0 && globalThis.gc) {
         globalThis.gc();
       }
     }
     if (globalThis.gc)
       globalThis.gc();
-    const finalMemory = process4.memoryUsage().heapUsed;
+    const finalMemory = process5.memoryUsage().heapUsed;
     const memoryGrowth = finalMemory - initialMemory;
     const memoryLeakDetected = memoryGrowth > 5 * 1024 * 1024;
     return {
@@ -12808,7 +12947,7 @@ function createLoadTester(client, config2) {
 }
 var performanceUtils = {
   getCurrentMemoryUsage: () => {
-    const usage = process4.memoryUsage();
+    const usage = process5.memoryUsage();
     return {
       heapUsed: usage.heapUsed,
       heapTotal: usage.heapTotal,
@@ -12817,7 +12956,7 @@ var performanceUtils = {
     };
   },
   getCPUUsage: () => {
-    const usage = process4.cpuUsage();
+    const usage = process5.cpuUsage();
     return {
       user: usage.user,
       system: usage.system
@@ -12952,14 +13091,14 @@ class TestResponseWrapper {
     }
     return this;
   }
-  expectRedirect(url) {
+  expectRedirect(url2) {
     if (this.status < 300 || this.status >= 400) {
       throw new Error(`Expected redirect status (3xx), got ${this.status}`);
     }
-    if (url) {
+    if (url2) {
       const location = this.headers.location;
-      if (location !== url) {
-        throw new Error(`Expected redirect to '${url}', got '${location}'`);
+      if (location !== url2) {
+        throw new Error(`Expected redirect to '${url2}', got '${location}'`);
       }
     }
     return this;
@@ -13102,24 +13241,24 @@ class TestClient {
   async request(method, path, options = {}) {
     const headers = { ...this.defaultHeaders, ...options.headers };
     const requestOptions = { ...options, headers };
-    const request = new TestRequestBuilder(method, path, requestOptions).build();
+    const request2 = new TestRequestBuilder(method, path, requestOptions).build();
     try {
-      const response2 = await this.handleRequest(request);
+      const response2 = await this.handleRequest(request2);
       return await createTestResponse(response2);
     } catch (error) {
       throw new Error(`Test request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  async handleRequest(request) {
-    const url = new URL(request.url);
-    const matchResult = this.findMatchingRoute(request.method, url.pathname);
+  async handleRequest(request2) {
+    const url2 = new URL(request2.url);
+    const matchResult = this.findMatchingRoute(request2.method, url2.pathname);
     if (!matchResult) {
       return new Response("Not Found", { status: 404 });
     }
     const { route, params } = matchResult;
-    request.params = { ...request.params, ...params };
+    request2.params = { ...request2.params, ...params };
     try {
-      const response2 = await this.executeMiddlewareChain(request, route);
+      const response2 = await this.executeMiddlewareChain(request2, route);
       return response2 || new Response("No response", { status: 500 });
     } catch (error) {
       return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal Server Error" }), {
@@ -13159,28 +13298,28 @@ class TestClient {
     }
     return params;
   }
-  async executeMiddlewareChain(request, route) {
+  async executeMiddlewareChain(request2, route) {
     const middlewares = [...this.router.globalMiddleware, ...route.middleware];
     let index = 0;
     const next = async () => {
       if (index < middlewares.length) {
         const middleware2 = middlewares[index++];
-        return await middleware2(request, next);
+        return await middleware2(request2, next);
       } else {
-        return await this.executeHandler(route.handler, request);
+        return await this.executeHandler(route.handler, request2);
       }
     };
     const result = await next();
     return result || new Response("No response", { status: 500 });
   }
-  async executeHandler(handler, request) {
+  async executeHandler(handler, request2) {
     if (typeof handler === "function") {
-      return await handler(request);
+      return await handler(request2);
     } else if (typeof handler === "string") {
       throw new TypeError(`String handlers not supported in test environment: ${handler}`);
     } else if (typeof handler === "object" && handler.handle) {
       const instance = new handler;
-      return await instance.handle(request);
+      return await instance.handle(request2);
     }
     throw new Error("Invalid handler type");
   }
@@ -13564,6 +13703,7 @@ export {
   verifySignature,
   validatePath,
   validate,
+  url,
   toActionPath,
   testRequest,
   testMiddlewareChain,
@@ -13574,10 +13714,12 @@ export {
   spyOnMiddleware,
   singleFileUpload,
   signRequest,
+  setCurrentRequest,
   session,
   securitySuite,
   security,
   scopedBindingHelpers,
+  runWithRequest,
   router,
   routeModelHelpers,
   routeCacheManager,
@@ -13588,6 +13730,8 @@ export {
   requestTracer,
   requestSigning,
   requestId,
+  request,
+  registerNamedRoute,
   rateLimitRegistry,
   rateLimit,
   processHtmlTemplate,
@@ -13615,6 +13759,9 @@ export {
   injectQueryPreservationScript,
   imageUpload,
   globalMiddlewarePipeline,
+  getNamedRoutes,
+  getNamedRoutePath,
+  getCurrentRequest,
   getConfig,
   generateSessionId,
   generateQueryPreservationScript,
@@ -13659,6 +13806,7 @@ export {
   contentSecurityPolicy,
   constraintHelpers,
   config,
+  clearNamedRoutes,
   buildUrlWithPreservedParams,
   benchmarkTests,
   benchmarkMiddleware,