@adonisjs/http-server 7.6.1 → 8.0.0-next.0

package/build/{chunk-7AGINHO3.js → chunk-VYBTM3NC.js}

@@ -1,22 +1,211 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+import {
+  __export,
+  default as default2,
+  default2 as default3,
+  parseRoute,
+  serializeCookie
+} from "./chunk-ASX56VAK.js";
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  E_CANNOT_LOOKUP_ROUTE: () => E_CANNOT_LOOKUP_ROUTE,
+  E_HTTP_EXCEPTION: () => E_HTTP_EXCEPTION,
+  E_HTTP_REQUEST_ABORTED: () => E_HTTP_REQUEST_ABORTED,
+  E_ROUTE_NOT_FOUND: () => E_ROUTE_NOT_FOUND
+});
+import { createError, Exception } from "@poppinss/utils/exception";
+var E_ROUTE_NOT_FOUND = createError(
+  "Cannot %s:%s",
+  "E_ROUTE_NOT_FOUND",
+  404
+);
+var E_CANNOT_LOOKUP_ROUTE = createError(
+  'Cannot lookup route "%s"',
+  "E_CANNOT_LOOKUP_ROUTE",
+  500
+);
+var E_HTTP_EXCEPTION = class HttpException extends Exception {
+  body;
+  static code = "E_HTTP_EXCEPTION";
+  /**
+   * This method returns an instance of the exception class
+   */
+  static invoke(body, status, code = "E_HTTP_EXCEPTION") {
+    if (body === null || body === void 0) {
+      const error2 = new this("HTTP Exception", { status, code });
+      error2.body = "Internal server error";
+      return error2;
+    }
+    if (typeof body === "object") {
+      const error2 = new this(body.message || "HTTP Exception", { status, code });
+      error2.body = body;
+      return error2;
+    }
+    const error = new this(body, { status, code });
+    error.body = body;
+    return error;
+  }
+};
+var E_HTTP_REQUEST_ABORTED = class AbortException extends E_HTTP_EXCEPTION {
+  handle(error, ctx) {
+    ctx.response.status(error.status).send(error.body);
+  }
+};
+
+// src/cookies/drivers/plain.ts
+import base64 from "@poppinss/utils/base64";
+import { MessageBuilder } from "@poppinss/utils";
+function pack(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return base64.urlEncode(new MessageBuilder().build(value));
+}
+function canUnpack(encodedValue) {
+  return typeof encodedValue === "string";
+}
+function unpack(encodedValue) {
+  return new MessageBuilder().verify(base64.urlDecode(encodedValue, "utf-8", false));
+}
+
+// src/cookies/drivers/signed.ts
+function pack2(key, value, encryption) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return `s:${encryption.verifier.sign(value, void 0, key)}`;
+}
+function canUnpack2(signedValue) {
+  return typeof signedValue === "string" && signedValue.substring(0, 2) === "s:";
+}
+function unpack2(key, signedValue, encryption) {
+  const value = signedValue.slice(2);
+  if (!value) {
+    return null;
+  }
+  return encryption.verifier.unsign(value, key);
+}
+
+// src/cookies/drivers/encrypted.ts
+function pack3(key, value, encryption) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return `e:${encryption.encrypt(value, void 0, key)}`;
+}
+function canUnpack3(encryptedValue) {
+  return typeof encryptedValue === "string" && encryptedValue.substring(0, 2) === "e:";
+}
+function unpack3(key, encryptedValue, encryption) {
+  const value = encryptedValue.slice(2);
+  if (!value) {
+    return null;
+  }
+  return encryption.decrypt(value, key);
+}
+
+// src/cookies/client.ts
+var CookieClient = class {
+  #encryption;
+  constructor(encryption) {
+    this.#encryption = encryption;
+  }
+  /**
+   * Encrypt a key value pair to be sent in the cookie header
+   */
+  encrypt(key, value) {
+    return pack3(key, value, this.#encryption);
+  }
+  /**
+   * Sign a key value pair to be sent in the cookie header
+   */
+  sign(key, value) {
+    return pack2(key, value, this.#encryption);
+  }
+  /**
+   * Encode a key value pair to be sent in the cookie header
+   */
+  encode(_, value, stringify2 = true) {
+    return stringify2 ? pack(value) : value;
+  }
+  /**
+   * Unsign a signed cookie value
+   */
+  unsign(key, value) {
+    return canUnpack2(value) ? unpack2(key, value, this.#encryption) : null;
+  }
+  /**
+   * Decrypt an encrypted cookie value
+   */
+  decrypt(key, value) {
+    return canUnpack3(value) ? unpack3(key, value, this.#encryption) : null;
+  }
+  /**
+   * Decode an encoded cookie value
+   */
+  decode(_, value, stringified = true) {
+    if (!stringified) {
+      return value;
+    }
+    return canUnpack(value) ? unpack(value) : null;
+  }
+  /**
+   * Parse response cookie
+   */
+  parse(key, value) {
+    if (canUnpack2(value)) {
+      return unpack2(key, value, this.#encryption);
+    }
+    if (canUnpack3(value)) {
+      return unpack3(key, value, this.#encryption);
+    }
+    if (canUnpack(value)) {
+      return unpack(value);
+    }
+  }
 };
 
+// src/tracing_channels.ts
+var tracing_channels_exports = {};
+__export(tracing_channels_exports, {
+  httpExceptionHandler: () => httpExceptionHandler,
+  httpMiddleware: () => httpMiddleware,
+  httpRequest: () => httpRequest,
+  httpResponseSerializer: () => httpResponseSerializer,
+  httpRouteHandler: () => httpRouteHandler
+});
+import diagnostics_channel from "diagnostics_channel";
+var httpRequest = diagnostics_channel.tracingChannel("adonisjs:http.request");
+var httpMiddleware = diagnostics_channel.tracingChannel("adonisjs:http.middleware");
+var httpExceptionHandler = diagnostics_channel.tracingChannel(
+  "adonisjs:http.exception.handler"
+);
+var httpRouteHandler = diagnostics_channel.tracingChannel("adonisjs:http.route.handler");
+var httpResponseSerializer = diagnostics_channel.tracingChannel(
+  "adonisjs:http.response.serializer"
+);
+
 // src/router/route.ts
 import is from "@sindresorhus/is";
 import Macroable4 from "@poppinss/macroable";
 import Middleware from "@poppinss/middleware";
-import { RuntimeException as RuntimeException2 } from "@poppinss/utils";
+import { RuntimeException as RuntimeException2 } from "@poppinss/utils/exception";
 import { moduleCaller, moduleImporter } from "@adonisjs/fold";
 
+// src/debug.ts
+import { debuglog } from "util";
+var debug_default = debuglog("adonisjs:http");
+
 // src/router/factories/use_return_value.ts
+function canWriteResponseBody(value, ctx) {
+  return value !== void 0 && // Return value is explicitly defined
+  !ctx.response.hasLazyBody && // Lazy body is not set
+  value !== ctx.response;
+}
 function useReturnValue(ctx) {
   return function(value) {
-    if (value !== void 0 && // Return value is explicitly defined
-    !ctx.response.hasLazyBody && // Lazy body is not set
-    value !== ctx.response) {
+    if (canWriteResponseBody(value, ctx)) {
       ctx.response.send(value);
     }
   };
@@ -24,22 +213,50 @@ function useReturnValue(ctx) {
 
 // src/router/executor.ts
 function execute(route, resolver, ctx, errorResponder) {
-  return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(async () => {
+  return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(() => {
     if (typeof route.handler === "function") {
-      return Promise.resolve(route.handler(ctx)).then(useReturnValue(ctx));
-    }
-    return route.handler.handle(resolver, ctx).then(useReturnValue(ctx));
+      return httpRouteHandler.tracePromise(
+        ($ctx) => Promise.resolve(route.handler($ctx)),
+        route,
+        void 0,
+        ctx
+      ).then(useReturnValue(ctx));
+    }
+    return httpRouteHandler.tracePromise(
+      route.handler.handle,
+      route,
+      void 0,
+      resolver,
+      ctx
+    ).then(useReturnValue(ctx));
   }).run(async (middleware, next) => {
     if (typeof middleware === "function") {
-      return middleware(ctx, next);
+      return httpMiddleware.tracePromise(
+        middleware,
+        middleware,
+        void 0,
+        ctx,
+        next
+      );
     }
-    return middleware.handle(resolver, ctx, next, middleware.args);
+    return httpMiddleware.tracePromise(
+      middleware.handle,
+      middleware,
+      void 0,
+      resolver,
+      ctx,
+      next,
+      middleware.args
+    );
   });
 }
 
-// src/helpers.ts
+// src/utils.ts
 import Cache from "tmp-cache";
-import { InvalidArgumentsException } from "@poppinss/utils";
+import { InvalidArgumentsException } from "@poppinss/utils/exception";
+
+// src/router/group.ts
+import Macroable3 from "@poppinss/macroable";
 
 // src/router/brisk.ts
 import Macroable from "@poppinss/macroable";
@@ -87,7 +304,8 @@ var BriskRoute = class extends Macroable {
    * Redirects to a given route. Params from the original request will
    * be used when no custom params are defined.
    */
-  redirect(identifier, params, options) {
+  redirect(...args) {
+    const [identifier, params, options] = args;
     function redirectsToRoute(ctx) {
       const redirector = ctx.response.redirect();
       if (options?.status) {
@@ -114,13 +332,10 @@ var BriskRoute = class extends Macroable {
   }
 };
 
-// src/router/group.ts
-import Macroable3 from "@poppinss/macroable";
-
 // src/router/resource.ts
 import string from "@poppinss/utils/string";
 import Macroable2 from "@poppinss/macroable";
-import { RuntimeException } from "@poppinss/utils";
+import { RuntimeException } from "@poppinss/utils/exception";
 var RouteResource = class extends Macroable2 {
   /**
    * Resource identifier. Nested resources are separated
@@ -534,7 +749,7 @@ var RouteGroup = class _RouteGroup extends Macroable3 {
   }
 };
 
-// src/helpers.ts
+// src/utils.ts
 var proxyCache = new Cache({ max: 200 });
 function dropSlash(input) {
   if (input === "/") {
@@ -600,10 +815,65 @@ function parseRange(range, value) {
     {}
   );
 }
-
-// src/debug.ts
-import { debuglog } from "node:util";
-var debug_default = debuglog("adonisjs:http");
+function decodeComponentChar(highCharCode, lowCharCode) {
+  if (highCharCode === 50) {
+    if (lowCharCode === 53) return "%";
+    if (lowCharCode === 51) return "#";
+    if (lowCharCode === 52) return "$";
+    if (lowCharCode === 54) return "&";
+    if (lowCharCode === 66) return "+";
+    if (lowCharCode === 98) return "+";
+    if (lowCharCode === 67) return ",";
+    if (lowCharCode === 99) return ",";
+    if (lowCharCode === 70) return "/";
+    if (lowCharCode === 102) return "/";
+    return null;
+  }
+  if (highCharCode === 51) {
+    if (lowCharCode === 65) return ":";
+    if (lowCharCode === 97) return ":";
+    if (lowCharCode === 66) return ";";
+    if (lowCharCode === 98) return ";";
+    if (lowCharCode === 68) return "=";
+    if (lowCharCode === 100) return "=";
+    if (lowCharCode === 70) return "?";
+    if (lowCharCode === 102) return "?";
+    return null;
+  }
+  if (highCharCode === 52 && lowCharCode === 48) {
+    return "@";
+  }
+  return null;
+}
+function safeDecodeURI(path, useSemicolonDelimiter) {
+  let shouldDecode = false;
+  let shouldDecodeParam = false;
+  let querystring = "";
+  for (let i = 1; i < path.length; i++) {
+    const charCode = path.charCodeAt(i);
+    if (charCode === 37) {
+      const highCharCode = path.charCodeAt(i + 1);
+      const lowCharCode = path.charCodeAt(i + 2);
+      if (decodeComponentChar(highCharCode, lowCharCode) === null) {
+        shouldDecode = true;
+      } else {
+        shouldDecodeParam = true;
+        if (highCharCode === 50 && lowCharCode === 53) {
+          shouldDecode = true;
+          path = path.slice(0, i + 1) + "25" + path.slice(i + 1);
+          i += 2;
+        }
+        i += 2;
+      }
+    } else if (charCode === 63 || charCode === 35 || charCode === 59 && useSemicolonDelimiter) {
+      querystring = path.slice(i + 1);
+      path = path.slice(0, i);
+      break;
+    }
+  }
+  const decodedPath = shouldDecode ? decodeURI(path) : path;
+  return { pathname: decodedPath, query: querystring, shouldDecodeParam };
+}
 
 // src/router/route.ts
 var Route = class extends Macroable4 {
@@ -850,16 +1120,20 @@ var Route = class extends Macroable4 {
       debug_default("adding named middleware to route %s, %O", this.#pattern, one);
       middleware.add(one);
     });
+    middleware.freeze();
     return middleware;
   }
   /**
    * Returns JSON representation of the route
    */
   toJSON() {
+    const pattern = this.#computePattern();
+    const matchers = this.#getMatchers();
     return {
       domain: this.#routeDomain,
-      pattern: this.#computePattern(),
-      matchers: this.#getMatchers(),
+      pattern,
+      matchers,
+      tokens: parseRoute(pattern, matchers),
       meta: {},
       name: this.#name,
       handler: this.#handler,
@@ -870,135 +1144,24 @@ var Route = class extends Macroable4 {
   }
 };
 
-// src/cookies/drivers/plain.ts
-import { base64, MessageBuilder } from "@poppinss/utils";
-function pack(value) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return base64.urlEncode(new MessageBuilder().build(value));
-}
-function canUnpack(encodedValue) {
-  return typeof encodedValue === "string";
-}
-function unpack(encodedValue) {
-  return new MessageBuilder().verify(base64.urlDecode(encodedValue, "utf-8", false));
-}
-
-// src/cookies/drivers/signed.ts
-function pack2(key, value, encryption) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return `s:${encryption.verifier.sign(value, void 0, key)}`;
-}
-function canUnpack2(signedValue) {
-  return typeof signedValue === "string" && signedValue.substring(0, 2) === "s:";
-}
-function unpack2(key, signedValue, encryption) {
-  const value = signedValue.slice(2);
-  if (!value) {
-    return null;
-  }
-  return encryption.verifier.unsign(value, key);
-}
-
-// src/cookies/drivers/encrypted.ts
-function pack3(key, value, encryption) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return `e:${encryption.encrypt(value, void 0, key)}`;
-}
-function canUnpack3(encryptedValue) {
-  return typeof encryptedValue === "string" && encryptedValue.substring(0, 2) === "e:";
-}
-function unpack3(key, encryptedValue, encryption) {
-  const value = encryptedValue.slice(2);
-  if (!value) {
-    return null;
-  }
-  return encryption.decrypt(value, key);
-}
+// src/request.ts
+import fresh from "fresh";
+import typeIs from "type-is";
+import accepts from "accepts";
+import { isIP } from "net";
+import is2 from "@sindresorhus/is";
+import proxyaddr from "proxy-addr";
+import { safeEqual } from "@poppinss/utils";
+import Macroable5 from "@poppinss/macroable";
+import lodash from "@poppinss/utils/lodash";
 
-// src/cookies/client.ts
-var CookieClient = class {
-  #encryption;
-  constructor(encryption) {
-    this.#encryption = encryption;
-  }
+// src/cookies/parser.ts
+import cookie from "cookie";
+var CookieParser = class {
+  #client;
   /**
-   * Encrypt a key value pair to be sent in the cookie header
-   */
-  encrypt(key, value) {
-    return pack3(key, value, this.#encryption);
-  }
-  /**
-   * Sign a key value pair to be sent in the cookie header
-   */
-  sign(key, value) {
-    return pack2(key, value, this.#encryption);
-  }
-  /**
-   * Encode a key value pair to be sent in the cookie header
-   */
-  encode(_, value) {
-    return pack(value);
-  }
-  /**
-   * Unsign a signed cookie value
-   */
-  unsign(key, value) {
-    return canUnpack2(value) ? unpack2(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decrypt an encrypted cookie value
-   */
-  decrypt(key, value) {
-    return canUnpack3(value) ? unpack3(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decode an encoded cookie value
-   */
-  decode(_, value) {
-    return canUnpack(value) ? unpack(value) : null;
-  }
-  /**
-   * Parse response cookie
-   */
-  parse(key, value) {
-    if (canUnpack2(value)) {
-      return unpack2(key, value, this.#encryption);
-    }
-    if (canUnpack3(value)) {
-      return unpack3(key, value, this.#encryption);
-    }
-    if (canUnpack(value)) {
-      return unpack(value);
-    }
-  }
-};
-
-// src/request.ts
-import fresh from "fresh";
-import typeIs from "type-is";
-import accepts from "accepts";
-import { isIP } from "node:net";
-import is2 from "@sindresorhus/is";
-import proxyaddr from "proxy-addr";
-import { safeEqual } from "@poppinss/utils";
-import Macroable5 from "@poppinss/macroable";
-import lodash from "@poppinss/utils/lodash";
-import { createId } from "@paralleldrive/cuid2";
-import { parse } from "node:url";
-
-// src/cookies/parser.ts
-import cookie from "cookie";
-var CookieParser = class {
-  #client;
-  /**
-   * A copy of cached cookies, they are cached during a request after
-   * initial decoding, unsigning or decrypting.
+   * A copy of cached cookies, they are cached during a request after
+   * initial decoding, unsigning or decrypting.
    */
   #cachedCookies = {
     signedCookies: {},
@@ -1025,10 +1188,10 @@ var CookieParser = class {
   }
   /**
    * Attempts to decode a cookie by the name. When calling this method,
-   * you are assuming that the cookie was just encoded in the first
+   * you are assuming that the cookie was just stringified in the first
    * place and not signed or encrypted.
    */
-  decode(key, encoded = true) {
+  decode(key, stringified = true) {
     const value = this.#cookies[key];
     if (value === null || value === void 0) {
       return null;
@@ -1037,7 +1200,7 @@ var CookieParser = class {
     if (cache[key] !== void 0) {
       return cache[key];
     }
-    const parsed = encoded ? this.#client.decode(key, value) : value;
+    const parsed = this.#client.decode(key, value, stringified);
     if (parsed !== null) {
       cache[key] = parsed;
     }
@@ -1100,7 +1263,7 @@ var Request = class extends Macroable5 {
     this.#qsParser = qsParser;
     this.#config = config;
     this.#encryption = encryption;
-    this.parsedUrl = parse(this.request.url, false);
+    this.parsedUrl = safeDecodeURI(request.url, false);
     this.#parseQueryString();
   }
   /**
@@ -1147,9 +1310,7 @@ var Request = class extends Macroable5 {
    */
   #cookieParser;
   /**
-   * Parses copy of the URL with query string as a string and not
-   * object. This is done to build URL's with query string without
-   * stringifying the object
+   * Parsed URL with query string stored as a string.
    */
   parsedUrl;
   /**
@@ -1189,7 +1350,7 @@ var Request = class extends Macroable5 {
   id() {
     let requestId = this.header("x-request-id");
     if (!requestId && this.#config.generateRequestId) {
-      requestId = createId();
+      requestId = this.#config.createRequestId();
       this.request.headers["x-request-id"] = requestId;
     }
     return requestId;
@@ -1462,11 +1623,11 @@ var Request = class extends Macroable5 {
     if ("encrypted" in this.request.socket) {
       return "https";
     }
-    if (!trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
-      return this.parsedUrl.protocol || "http";
+    if (trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
+      const forwardedProtocol = this.header("X-Forwarded-Proto");
+      return forwardedProtocol ? forwardedProtocol.split(/\s*,\s*/)[0] : "http";
     }
-    const forwardedProtocol = this.header("X-Forwarded-Proto");
-    return forwardedProtocol ? forwardedProtocol.split(/\s*,\s*/)[0] : "http";
+    return "http";
   }
   /**
    * Returns a boolean telling if request is served over `https`
@@ -1896,8 +2057,7 @@ var Request = class extends Macroable5 {
 };
 
 // src/redirect.ts
-import { parse as parse2 } from "node:url";
-import encodeUrl from "encodeurl";
+import { parse } from "url";
 var Redirect = class {
   /**
    * A boolean to forward the existing query string
@@ -1928,7 +2088,7 @@ var Redirect = class {
     const stringified = this.#qs.stringify(query);
     url = stringified ? `${url}?${stringified}` : url;
     debug_default('redirecting to url "%s"', url);
-    this.#response.location(encodeUrl(url));
+    this.#response.location(default2(url));
     this.#response.safeStatus(this.#statusCode);
     this.#response.type("text/plain; charset=utf-8");
     this.#response.send(`Redirecting to ${url}`);
@@ -1974,7 +2134,7 @@ var Redirect = class {
   back() {
     let query = {};
     const referrerUrl = this.#getReferrerUrl();
-    const url = parse2(referrerUrl);
+    const url = parse(referrerUrl);
     debug_default('referrer url "%s"', referrerUrl);
     debug_default('referrer base url "%s"', url.pathname);
     if (this.#forwardQueryString) {
@@ -1986,12 +2146,13 @@ var Redirect = class {
   /**
    * Redirect the request using a route identifier.
    */
-  toRoute(routeIdentifier, params, options) {
+  toRoute(...args) {
+    const [identifier, params, options] = args;
     if (options && options.qs) {
       this.withQs(options.qs);
       options.qs = void 0;
     }
-    const url = this.#router.makeUrl(routeIdentifier, params, options);
+    const url = this.#router.urlBuilder.urlFor(identifier, params, options);
     return this.toPath(url);
   }
   /**
@@ -2000,60 +2161,13 @@ var Redirect = class {
   toPath(url) {
     let query = {};
     if (this.#forwardQueryString) {
-      query = this.#qs.parse(parse2(this.#request.url).query || "");
+      query = this.#qs.parse(parse(this.#request.url).query || "");
     }
     Object.assign(query, this.#queryString);
     this.#sendResponse(url, query);
   }
 };
 
-// src/exceptions.ts
-var exceptions_exports = {};
-__export(exceptions_exports, {
-  E_CANNOT_LOOKUP_ROUTE: () => E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION: () => E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED: () => E_HTTP_REQUEST_ABORTED,
-  E_ROUTE_NOT_FOUND: () => E_ROUTE_NOT_FOUND
-});
-import { createError, Exception } from "@poppinss/utils";
-var E_ROUTE_NOT_FOUND = createError(
-  "Cannot %s:%s",
-  "E_ROUTE_NOT_FOUND",
-  404
-);
-var E_CANNOT_LOOKUP_ROUTE = createError(
-  'Cannot lookup route "%s"',
-  "E_CANNOT_LOOKUP_ROUTE",
-  500
-);
-var E_HTTP_EXCEPTION = class HttpException extends Exception {
-  body;
-  static code = "E_HTTP_EXCEPTION";
-  /**
-   * This method returns an instance of the exception class
-   */
-  static invoke(body, status, code = "E_HTTP_EXCEPTION") {
-    if (body === null || body === void 0) {
-      const error2 = new this("HTTP Exception", { status, code });
-      error2.body = "Internal server error";
-      return error2;
-    }
-    if (typeof body === "object") {
-      const error2 = new this(body.message || "HTTP Exception", { status, code });
-      error2.body = body;
-      return error2;
-    }
-    const error = new this(body, { status, code });
-    error.body = body;
-    return error;
-  }
-};
-var E_HTTP_REQUEST_ABORTED = class AbortException extends E_HTTP_EXCEPTION {
-  handle(error, ctx) {
-    ctx.response.status(error.status).send(error.body);
-  }
-};
-
 // src/response_status.ts
 var ResponseStatus = {
   Continue: 100,
@@ -2121,58 +2235,44 @@ var ResponseStatus = {
 };
 
 // src/response.ts
-import { Buffer as Buffer2 } from "node:buffer";
 import etag from "etag";
 import vary from "vary";
 import fresh2 from "fresh";
-import mime from "mime-types";
 import destroy from "destroy";
-import { extname } from "node:path";
+import { extname } from "path";
+import { Buffer } from "buffer";
 import onFinished from "on-finished";
-import json from "@poppinss/utils/json";
+import { stat } from "fs/promises";
 import Macroable6 from "@poppinss/macroable";
-import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { RuntimeException as RuntimeException3 } from "@poppinss/utils";
+import { createReadStream } from "fs";
 import contentDisposition from "content-disposition";
+import { safeStringify } from "@poppinss/utils/json";
+import { RuntimeException as RuntimeException3 } from "@poppinss/utils/exception";
 
 // src/cookies/serializer.ts
-import cookie2 from "cookie";
-import string2 from "@poppinss/utils/string";
 var CookieSerializer = class {
   #client;
   constructor(encryption) {
     this.#client = new CookieClient(encryption);
   }
-  /**
-   * Serializes the key-value pair to a string, that can be set on the
-   * `Set-Cookie` header.
-   */
-  #serializeAsCookie(key, value, options) {
-    let expires = options?.expires;
-    if (typeof expires === "function") {
-      expires = expires();
-    }
-    let maxAge = options?.maxAge ? string2.seconds.parse(options?.maxAge) : void 0;
-    const parsedOptions = Object.assign({}, options, { maxAge, expires });
-    return cookie2.serialize(key, value, parsedOptions);
-  }
   /**
    * Encodes value as a plain cookie. By default, the plain value will be converted
    * to a string using "JSON.stringify" method and then encoded as a base64 string.
    *
-   * You can disable encoding of the cookie by setting `options.encoded = false`.
+   * You can disable cookie stringifaction by setting `options.stringify = false`.
    *
    * ```ts
    *  serializer.encode('name', 'virk')
+   *  serializer.encode('name', 'virk', { stringify: false })
    * ```
    */
   encode(key, value, options) {
-    const packedValue = options?.encode === false ? value : this.#client.encode(key, value);
+    const stringify2 = options?.stringify ?? options?.encode;
+    const packedValue = this.#client.encode(key, value, stringify2);
     if (packedValue === null || packedValue === void 0) {
       return null;
     }
-    return this.#serializeAsCookie(key, packedValue, options);
+    return serializeCookie(key, packedValue, options);
   }
   /**
    * Sign a key-value pair to a signed cookie. The signed value has a
@@ -2183,7 +2283,7 @@ var CookieSerializer = class {
     if (packedValue === null) {
       return null;
     }
-    return this.#serializeAsCookie(key, packedValue, options);
+    return serializeCookie(key, packedValue, options);
   }
   /**
    * Encrypts a key-value pair to an encrypted cookie.
@@ -2193,7 +2293,7 @@ var CookieSerializer = class {
     if (packedValue === null) {
       return null;
     }
-    return this.#serializeAsCookie(key, packedValue, options);
+    return serializeCookie(key, packedValue, options);
   }
 };
 
@@ -2344,20 +2444,20 @@ var Response = class extends Macroable6 {
    * - Buffer
    */
   #getDataType(content) {
-    if (content instanceof Uint8Array) {
-      return "buffer";
-    }
-    if (content instanceof Date) {
-      return "date";
-    }
-    if (content instanceof RegExp) {
-      return "regexp";
-    }
     const dataType = typeof content;
     if (dataType === "number" || dataType === "boolean" || dataType === "string" || dataType === "bigint") {
       return dataType;
     }
     if (dataType === "object") {
+      if (content instanceof Uint8Array) {
+        return "buffer";
+      }
+      if (content instanceof RegExp) {
+        return "regexp";
+      }
+      if (content instanceof Date) {
+        return "date";
+      }
       return "object";
     }
     throw new RuntimeException3(`Cannot serialize "${dataType}" to HTTP response`);
@@ -2387,12 +2487,29 @@ var Response = class extends Macroable6 {
       return;
     }
     const dataType = this.#getDataType(content);
-    if (dataType === "object") {
-      content = json.safeStringify(content);
-    } else if (dataType === "number" || dataType === "boolean" || dataType === "bigint" || dataType === "regexp") {
-      content = String(content);
-    } else if (dataType === "date") {
-      content = content.toISOString();
+    let contentType;
+    switch (dataType) {
+      case "string":
+        contentType = content.trimStart().startsWith("<") ? "text/html; charset=utf-8" : "text/plain; charset=utf-8";
+        break;
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "regexp":
+        content = String(content);
+        contentType = "text/plain; charset=utf-8";
+        break;
+      case "date":
+        content = content.toISOString();
+        contentType = "text/plain; charset=utf-8";
+        break;
+      case "buffer":
+        contentType = "application/octet-stream; charset=utf-8";
+        break;
+      case "object":
+        content = safeStringify(content);
+        contentType = "application/json; charset=utf-8";
+        break;
     }
     if (jsonpCallbackName) {
       content = content.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
@@ -2409,30 +2526,12 @@ var Response = class extends Macroable6 {
       return;
     }
     this.setRequestId();
-    this.header("Content-Length", Buffer2.byteLength(content));
+    this.header("Content-Length", Buffer.byteLength(content));
     if (jsonpCallbackName) {
       this.header("X-Content-Type-Options", "nosniff");
       this.safeHeader("Content-Type", "text/javascript; charset=utf-8");
     } else {
-      switch (dataType) {
-        case "string":
-          const type = /^\s*</.test(content) ? "text/html" : "text/plain";
-          this.safeHeader("Content-Type", `${type}; charset=utf-8`);
-          break;
-        case "number":
-        case "boolean":
-        case "date":
-        case "bigint":
-        case "regexp":
-          this.safeHeader("Content-Type", "text/plain; charset=utf-8");
-          break;
-        case "buffer":
-          this.safeHeader("Content-Type", "application/octet-stream; charset=utf-8");
-          break;
-        case "object":
-          this.safeHeader("Content-Type", "application/json; charset=utf-8");
-          break;
-      }
+      this.safeHeader("Content-type", contentType);
     }
     this.#endResponse(content);
   }
@@ -2669,7 +2768,7 @@ var Response = class extends Macroable6 {
    */
   type(type, charset) {
     type = charset ? `${type}; charset=${charset}` : type;
-    this.header("Content-Type", mime.contentType(type));
+    this.header("Content-Type", default3.contentType(type));
     return this;
   }
   /**
@@ -2956,7 +3055,7 @@ var Response = class extends Macroable6 {
       return;
     }
     if (this.content) {
-      this.writeBody(...this.content);
+      httpResponseSerializer.traceSync(this.writeBody, void 0, this, ...this.content);
       return;
     }
     if (this.lazyBody.stream) {
@@ -3267,22 +3366,13 @@ var Response = class extends Macroable6 {
 
 // src/router/main.ts
 import is3 from "@sindresorhus/is";
+import lodash2 from "@poppinss/utils/lodash";
 import { moduleImporter as moduleImporter3 } from "@adonisjs/fold";
-import { RuntimeException as RuntimeException6 } from "@poppinss/utils";
+import { RuntimeException as RuntimeException5 } from "@poppinss/utils/exception";
 
 // src/router/store.ts
-import matchit2 from "@poppinss/matchit";
-import lodash2 from "@poppinss/utils/lodash";
-import { RuntimeException as RuntimeException4 } from "@poppinss/utils";
-
-// src/router/parser.ts
 import matchit from "@poppinss/matchit";
-function parseRoutePattern(pattern, matchers) {
-  const tokens = matchit.parse(pattern, matchers);
-  return tokens;
-}
-
-// src/router/store.ts
+import { RuntimeException as RuntimeException4 } from "@poppinss/utils/exception";
 var RoutesStore = class {
   /**
    * A flag to know if routes for explicit domains
@@ -3298,7 +3388,7 @@ var RoutesStore = class {
    */
   #getDomainNode(domain) {
     if (!this.tree.domains[domain]) {
-      this.tree.tokens.push(parseRoutePattern(domain));
+      this.tree.tokens.push(parseRoute(domain));
       this.tree.domains[domain] = {};
     }
     return this.tree.domains[domain];
@@ -3367,14 +3457,10 @@ var RoutesStore = class {
     if (route.domain !== "root") {
       this.usingDomains = true;
     }
-    const tokens = parseRoutePattern(route.pattern, route.matchers);
-    const routeNode = lodash2.merge(
-      { meta: {} },
-      lodash2.pick(route, ["pattern", "handler", "meta", "middleware", "name", "execute"])
-    );
-    routeNode.meta.params = this.#collectRouteParams(routeNode, tokens);
+    const routeNode = { ...route };
+    routeNode.meta.params = this.#collectRouteParams(routeNode, route.tokens);
     route.methods.forEach((method) => {
-      this.#registerRoute(route.domain, method, tokens, routeNode);
+      this.#registerRoute(route.domain, method, route.tokens, routeNode);
     });
     return this;
   }
@@ -3387,7 +3473,7 @@ var RoutesStore = class {
    * qualified runtime domain. You must call `matchDomain` first to fetch
    * the pattern for qualified domain
    */
-  match(url, method, domain) {
+  match(url, method, shouldDecodeParam, domain) {
     const domainName = domain?.tokens[0]?.old || "root";
     const matchedDomain = this.tree.domains[domainName];
     if (!matchedDomain) {
@@ -3397,7 +3483,7 @@ var RoutesStore = class {
     if (!matchedMethod) {
       return null;
     }
-    const matchedRoute = matchit2.match(url, matchedMethod.tokens);
+    const matchedRoute = matchit.match(url, matchedMethod.tokens);
     if (!matchedRoute.length) {
       return null;
     }
@@ -3405,8 +3491,8 @@ var RoutesStore = class {
     return {
       route,
       routeKey: matchedMethod.routeKeys[route.pattern],
-      params: matchit2.exec(url, matchedRoute),
-      subdomains: domain?.hostname ? matchit2.exec(domain.hostname, domain.tokens) : {}
+      params: matchit.exec(url, matchedRoute, shouldDecodeParam),
+      subdomains: domain?.hostname ? matchit.exec(domain.hostname, domain.tokens) : {}
     };
   }
   /**
@@ -3416,120 +3502,149 @@ var RoutesStore = class {
     if (!hostname || !this.usingDomains) {
       return [];
     }
-    return matchit2.match(hostname, this.tree.tokens);
+    return matchit.match(hostname, this.tree.tokens);
   }
 };
 
-// src/router/lookup_store/main.ts
-import Macroable7 from "@poppinss/macroable";
-
-// src/router/lookup_store/url_builder.ts
-import { RuntimeException as RuntimeException5 } from "@poppinss/utils";
-var UrlBuilder = class {
+// src/client/router.ts
+var RouterClient = class {
   /**
-   * Query string parser
+   * List of route references kept for lookup.
    */
-  #qsParser;
+  routes;
   /**
-   * The parameters to apply on the route
+   * The lookup strategies to follow when generating URL builder
+   * types and client
    */
-  #params = {};
+  lookupStrategies = ["name", "pattern"];
+  constructor(routes) {
+    this.routes = routes ?? {};
+  }
   /**
-   * Query string to append to the route
+   * Register route JSON payload
    */
-  #qs = {};
+  register(route) {
+    this.routes[route.domain] = this.routes[route.domain] || [];
+    this.routes[route.domain].push(route);
+  }
   /**
-   * Should we perform the route lookup or just build the
-   * given pattern as it is.
+   * Define the lookup strategies to follow when generating URL builder
+   * types and client.
    */
-  #shouldPerformLookup = true;
+  updateLookupStrategies(strategies) {
+    this.lookupStrategies = strategies;
+    return this;
+  }
   /**
-   * BaseURL to append to the constructored URL
-   */
-  #baseUrl;
+   * Finds a route by its identifier. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * When "followLookupStrategy" is enabled, the lookup will be performed
+   * on the basis of the lookup strategy enabled via the "lookupStrategies"
+   * method. The default lookupStrategy is "name" and "pattern".
+   */
+  find(routeIdentifier, domain, method, followLookupStrategy) {
+    if (!domain) {
+      let route = null;
+      for (const routeDomain of Object.keys(this.routes)) {
+        route = this.find(routeIdentifier, routeDomain, method, followLookupStrategy);
+        if (route) {
+          break;
+        }
+      }
+      return route;
+    }
+    const routes = this.routes[domain];
+    if (!routes) {
+      return null;
+    }
+    const lookupByName = !followLookupStrategy || this.lookupStrategies.includes("name");
+    const lookupByPattern = !followLookupStrategy || this.lookupStrategies.includes("pattern");
+    const lookupByController = !followLookupStrategy || this.lookupStrategies.includes("controller");
+    return routes.find((route) => {
+      if (method && !route.methods.includes(method)) {
+        return false;
+      }
+      if (route.name === routeIdentifier && lookupByName || route.pattern === routeIdentifier && lookupByPattern) {
+        return true;
+      }
+      if (typeof route.handler === "function" || !lookupByController) {
+        return false;
+      }
+      return route.handler.reference === routeIdentifier;
+    }) || null;
+  }
   /**
-   * Encryption class for making signed URLs
+   * Finds a route by its identifier. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * An error is raised when unable to find the route.
+   *
+   * When "followLookupStrategy" is enabled, the lookup will be performed
+   * on the basis of the lookup strategy enabled via the "lookupStrategies"
+   * method. The default lookupStrategy is "name" and "pattern".
    */
-  #encryption;
+  findOrFail(routeIdentifier, domain, method, followLookupStrategy) {
+    const route = this.find(routeIdentifier, domain, method, followLookupStrategy);
+    if (!route) {
+      throw new Error(`Cannot lookup route "${routeIdentifier}"`);
+    }
+    return route;
+  }
   /**
-   * Route finder for finding route pattern
+   * Check if a route exists. The identifier can be the
+   * route name, controller.method name or the route pattern
+   * itself.
+   *
+   * When "followLookupStrategy" is enabled, the lookup will be performed
+   * on the basis of the lookup strategy enabled via the "lookupStrategies"
+   * method. The default lookupStrategy is "name" and "pattern".
    */
-  #routeFinder;
-  constructor(encryption, routeFinder, qsParser) {
-    this.#qsParser = qsParser;
-    this.#encryption = encryption;
-    this.#routeFinder = routeFinder;
+  has(routeIdentifier, domain, method, followLookupStrategy) {
+    return !!this.find(routeIdentifier, domain, method, followLookupStrategy);
   }
   /**
-   * Raises exception when wildcard values array is missing or
-   * has length of zero.
+   * Returns a list of routes grouped by their domain names
    */
-  #ensureHasWildCardValues(pattern, values) {
-    if (!values || !Array.isArray(values) || !values.length) {
-      throw new RuntimeException5(
-        `Cannot make URL for "${pattern}" route. Invalid value provided for wildcard param`
-      );
-    }
+  toJSON() {
+    return this.routes;
   }
-  /*
-   * Raises exception when value is not defined
+};
+
+// src/router/legacy/url_builder.ts
+var UrlBuilder = class {
+  /**
+   * The parameters to apply on the route
    */
-  #ensureHasParamValue(pattern, param, value) {
-    if (value === void 0 || value === null) {
-      throw new RuntimeException5(
-        `Cannot make URL for "${pattern}" route. Missing value for "${param}" param`
-      );
-    }
-  }
+  #params = {};
   /**
-   * Processes the pattern against the params
+   * Query string to append to the route
    */
-  #processPattern(pattern) {
-    const uriSegments = [];
-    const paramsArray = Array.isArray(this.#params) ? this.#params : null;
-    const paramsObject = !Array.isArray(this.#params) ? this.#params : {};
-    let paramsIndex = 0;
-    const tokens = parseRoutePattern(pattern);
-    for (const token of tokens) {
-      if (token.type === 0) {
-        uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
-      } else if (token.type === 2) {
-        const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
-        this.#ensureHasWildCardValues(pattern, values);
-        uriSegments.push(`${values.join("/")}${token.end}`);
-        break;
-      } else {
-        const paramName = token.val;
-        const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
-        if (token.type === 1) {
-          this.#ensureHasParamValue(pattern, paramName, value);
-        }
-        paramsIndex++;
-        if (value !== void 0 && value !== null) {
-          uriSegments.push(`${value}${token.end}`);
-        }
-      }
-    }
-    return `/${uriSegments.join("/")}`;
-  }
+  #qs = {};
   /**
-   * Suffix the query string to the URL
+   * Should we perform the route lookup or just build the
+   * given pattern as it is.
    */
-  #suffixQueryString(url, qs) {
-    if (qs) {
-      const queryString = this.#qsParser.stringify(qs);
-      url = queryString ? `${url}?${queryString}` : url;
-    }
-    return url;
-  }
+  #shouldPerformLookup = true;
   /**
-   * Prefixes base URL to the uri string
+   * BaseURL to append to the constructored URL
    */
-  #prefixBaseUrl(uri) {
-    return this.#baseUrl ? `${this.#baseUrl}${uri}` : uri;
+  #baseUrl;
+  /**
+   * Route finder for finding route pattern
+   */
+  #router;
+  #domain;
+  constructor(router, domain) {
+    this.#router = router;
+    this.#domain = domain;
   }
   /**
    * Prefix a custom base URL to the final URI
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
    */
   prefixUrl(url) {
     this.#baseUrl = url;
@@ -3538,6 +3653,8 @@ var UrlBuilder = class {
   /**
    * Disable route lookup. Calling this method considers
    * the "identifier" as the route pattern
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
    */
   disableRouteLookup() {
     this.#shouldPerformLookup = false;
@@ -3545,6 +3662,8 @@ var UrlBuilder = class {
   }
   /**
    * Append query string to the final URI
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
    */
   qs(queryString) {
     if (!queryString) {
@@ -3555,6 +3674,8 @@ var UrlBuilder = class {
   }
   /**
    * Specify params to apply to the route pattern
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
    */
   params(params) {
     if (!params) {
@@ -3567,174 +3688,41 @@ var UrlBuilder = class {
    * Generate URL for the given route identifier. The identifier can be the
    * route name, controller.method name or the route pattern
    * itself.
+   *
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
    */
   make(identifier) {
-    let url;
-    if (this.#shouldPerformLookup) {
-      const route = this.#routeFinder.findOrFail(identifier);
-      url = this.#processPattern(route.pattern);
-    } else {
-      url = this.#processPattern(identifier);
-    }
-    return this.#suffixQueryString(this.#prefixBaseUrl(url), this.#qs);
+    return this.#router.makeUrl(identifier, this.#params, {
+      prefixUrl: this.#baseUrl,
+      disableRouteLookup: !this.#shouldPerformLookup,
+      domain: this.#domain,
+      qs: this.#qs
+    });
   }
   /**
    * Generate a signed URL for the given route identifier. The identifier can be the
    * route name, controller.method name or the route pattern
    * itself.
-   */
-  makeSigned(identifier, options) {
-    let url;
-    if (this.#shouldPerformLookup) {
-      const route = this.#routeFinder.findOrFail(identifier);
-      url = this.#processPattern(route.pattern);
-    } else {
-      url = this.#processPattern(identifier);
-    }
-    const signature = this.#encryption.verifier.sign(
-      this.#suffixQueryString(url, this.#qs),
-      options?.expiresIn,
-      options?.purpose
-    );
-    const qs = Object.assign({}, this.#qs, { signature });
-    return this.#suffixQueryString(this.#prefixBaseUrl(url), qs);
-  }
-};
-
-// src/router/lookup_store/route_finder.ts
-var RouteFinder = class {
-  #routes = [];
-  register(route) {
-    this.#routes.push(route);
-  }
-  /**
-   * Find a route by indentifier
-   */
-  find(routeIdentifier) {
-    return this.#routes.find(({ name, pattern, handler }) => {
-      if (name === routeIdentifier || pattern === routeIdentifier) {
-        return true;
-      }
-      if (typeof handler === "function") {
-        return false;
-      }
-      return handler.reference === routeIdentifier;
-    }) || null;
-  }
-  /**
-   * Find a route by indentifier or fail
-   */
-  findOrFail(routeIdentifier) {
-    const route = this.find(routeIdentifier);
-    if (!route) {
-      throw new E_CANNOT_LOOKUP_ROUTE([routeIdentifier]);
-    }
-    return route;
-  }
-  /**
-   * Find if a route exists
-   */
-  has(routeIdentifier) {
-    return !!this.find(routeIdentifier);
-  }
-  /**
-   * Returns an array of registered routes
-   */
-  toJSON() {
-    return this.#routes;
-  }
-};
-
-// src/router/lookup_store/main.ts
-var LookupStore = class extends Macroable7 {
-  /**
-   * List of route finders grouped by domains
-   */
-  #routes = {};
-  /**
-   * Encryption for making URLs
-   */
-  #encryption;
-  /**
-   * Query string parser for making URLs
-   */
-  #qsParser;
-  constructor(encryption, qsParser) {
-    super();
-    this.#encryption = encryption;
-    this.#qsParser = qsParser;
-  }
-  /**
-   * Register route JSON payload
-   */
-  register(route) {
-    this.#routes[route.domain] = this.#routes[route.domain] || new RouteFinder();
-    this.#routes[route.domain].register(route);
-  }
-  /**
-   * Returns an instance of the URL builder for making
-   * route URIs
-   */
-  builder() {
-    return this.builderForDomain("root");
-  }
-  /**
-   * Returns an instance of the URL builder for a specific
-   * domain.
-   */
-  builderForDomain(domain) {
-    const finder = this.#routes[domain];
-    return new UrlBuilder(this.#encryption, finder || new RouteFinder(), this.#qsParser);
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  find(routeIdentifier, domain) {
-    const finder = this.#routes[domain || "root"];
-    if (!finder) {
-      return null;
-    }
-    return finder.find(routeIdentifier);
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
    *
-   * An error is raised when unable to find the route.
-   */
-  findOrFail(routeIdentifier, domain) {
-    const finder = this.#routes[domain || "root"];
-    if (!finder) {
-      throw new E_CANNOT_LOOKUP_ROUTE([routeIdentifier]);
-    }
-    return finder.findOrFail(routeIdentifier);
-  }
-  /**
-   * Check if a route exists. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder" instead
+   *
    */
-  has(routeIdentifier, domain) {
-    const finder = this.#routes[domain || "root"];
-    if (!finder) {
-      return false;
-    }
-    return finder.has(routeIdentifier);
-  }
-  toJSON() {
-    return Object.keys(this.#routes).reduce((result, domain) => {
-      result[domain] = this.#routes[domain].toJSON();
-      return result;
-    }, {});
+  makeSigned(identifier, options) {
+    return this.#router.makeSignedUrl(identifier, this.#params, {
+      prefixUrl: this.#baseUrl,
+      disableRouteLookup: !this.#shouldPerformLookup,
+      domain: this.#domain,
+      qs: this.#qs,
+      ...options
+    });
   }
 };
 
 // src/router/matchers.ts
-import Macroable8 from "@poppinss/macroable";
-var RouteMatchers = class extends Macroable8 {
+import Macroable7 from "@poppinss/macroable";
+var RouteMatchers = class extends Macroable7 {
   /**
    * Enforce value to be a number and also casts it to number data
    * type
@@ -3767,6 +3755,7 @@ function middlewareReferenceBuilder(name, middleware) {
     return {
       ...handler,
       name,
+      reference: middleware,
       args: args[0]
     };
   };
@@ -3781,8 +3770,225 @@ function defineNamedMiddleware(collection) {
   );
 }
 
+// src/client/url_builder.ts
+function createURL(identifier, tokens, searchParamsStringifier, params, options) {
+  const uriSegments = [];
+  const paramsArray = Array.isArray(params) ? params : null;
+  const paramsObject = !Array.isArray(params) ? params ?? {} : {};
+  let paramsIndex = 0;
+  for (const token of tokens) {
+    if (token.type === 0) {
+      uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
+      continue;
+    }
+    if (token.type === 2) {
+      const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
+      if (!Array.isArray(values) || !values.length) {
+        throw new Error(
+          `Cannot make URL for "${identifier}". Invalid value provided for the wildcard param`
+        );
+      }
+      uriSegments.push(`${values.join("/")}${token.end}`);
+      break;
+    }
+    const paramName = token.val;
+    const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
+    const isDefined = value !== void 0 && value !== null;
+    if (token.type === 1 && !isDefined) {
+      throw new Error(
+        `Cannot make URL for "${identifier}". Missing value for the "${paramName}" param`
+      );
+    }
+    if (isDefined) {
+      uriSegments.push(`${value}${token.end}`);
+    }
+    paramsIndex++;
+  }
+  let URI = `/${uriSegments.join("/")}`;
+  if (options?.prefixUrl) {
+    URI = `${options?.prefixUrl.replace(/\/$/, "")}${URI}`;
+  }
+  if (options?.qs) {
+    const queryString = searchParamsStringifier(options?.qs);
+    URI = queryString ? `${URI}?${queryString}` : URI;
+  }
+  return URI;
+}
+function createUrlBuilder(router, searchParamsStringifier) {
+  let domainsList;
+  function createUrlForRoute(identifier, params, options, method) {
+    if (!domainsList) {
+      domainsList = Object.keys(router.toJSON()).filter((domain2) => domain2 !== "root");
+    }
+    const domain = domainsList.find((name) => identifier.startsWith(`${name}@`));
+    const routeIdentifier = domain ? identifier.replace(new RegExp(`^${domain}@`), "") : identifier;
+    const route = router.findOrFail(routeIdentifier, domain, method, true);
+    return createURL(
+      route.name ?? route.pattern,
+      route.tokens,
+      searchParamsStringifier,
+      params,
+      options
+    );
+  }
+  const urlFor = function route(...[identifier, params, options]) {
+    return createUrlForRoute(identifier, params, options);
+  };
+  urlFor.get = function urlForMethodGet(...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, "GET"),
+      method: "get",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  urlFor.post = function urlForMethodPost(...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, "POST"),
+      method: "post",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  urlFor.put = function urlForMethodPut(...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, "PUT"),
+      method: "put",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  urlFor.patch = function urlForMethodPatch(...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, "PATCH"),
+      method: "patch",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  urlFor.delete = function urlForMethodDelete(...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, "DELETE"),
+      method: "delete",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  urlFor.method = function urlForCustomMethod(method, ...[identifier, params, options]) {
+    return {
+      url: createUrlForRoute(identifier, params, options, method),
+      method,
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  return urlFor;
+}
+
+// src/router/signed_url_builder.ts
+function createSignedURL(identifier, tokens, searchParamsStringifier, encryption, params, options) {
+  const signature = encryption.verifier.sign(
+    createURL(identifier, tokens, searchParamsStringifier, params, {
+      ...options,
+      prefixUrl: void 0
+    }),
+    options?.expiresIn,
+    options?.purpose
+  );
+  return createURL(identifier, tokens, searchParamsStringifier, params, {
+    ...options,
+    qs: { ...options?.qs, signature }
+  });
+}
+function createSignedUrlBuilder(router, encryption, searchParamsStringifier) {
+  let domainsList;
+  function createSignedUrlForRoute(identifier, params, options, method) {
+    if (!domainsList) {
+      domainsList = Object.keys(router.toJSON()).filter((domain2) => domain2 !== "root");
+    }
+    const domain = domainsList.find((name) => identifier.startsWith(`${name}@`));
+    const routeIdentifier = domain ? identifier.replace(new RegExp(`^${domain}@`), "") : identifier;
+    const route = router.findOrFail(routeIdentifier, domain, method, true);
+    return createSignedURL(
+      route.name ?? route.pattern,
+      route.tokens,
+      searchParamsStringifier,
+      encryption,
+      params,
+      options
+    );
+  }
+  const signedRoute = function route(...[identifier, params, options]) {
+    return createSignedUrlForRoute(identifier, params, options);
+  };
+  signedRoute.get = function routeGet(...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, "GET"),
+      method: "get",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  signedRoute.post = function routePost(...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, "POST"),
+      method: "post",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  signedRoute.put = function routePut(...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, "PUT"),
+      method: "put",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  signedRoute.patch = function routePatch(...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, "PATCH"),
+      method: "patch",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  signedRoute.delete = function routeDelete(...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, "DELETE"),
+      method: "delete",
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  signedRoute.method = function routeGet(method, ...[identifier, params, options]) {
+    return {
+      url: createSignedUrlForRoute(identifier, params, options, method),
+      method,
+      toString() {
+        return this.url;
+      }
+    };
+  };
+  return signedRoute;
+}
+
 // src/router/main.ts
-var Router = class extends LookupStore {
+var Router = class extends RouterClient {
+  /**
+   * Flag to avoid re-comitting routes to the store
+   */
   #commited = false;
   /**
    * Application is needed to resolve string based controller expressions
@@ -3792,6 +3998,10 @@ var Router = class extends LookupStore {
    * Store with tokenized routes
    */
   #store = new RoutesStore();
+  /**
+   * Encryption for making signed URLs
+   */
+  #encryption;
   /**
    * Global matchers to test route params against regular expressions.
    */
@@ -3806,10 +4016,10 @@ var Router = class extends LookupStore {
    */
   #openedGroups = [];
   /**
-   * Collection of routes, including route resource and route
-   * group. To get a flat list of routes, call `router.toJSON()`
+   * Collection of routes to be committed with the store, including
+   * route resource and route group.
    */
-  routes = [];
+  #routesToBeCommitted = [];
   /**
    * A flag to know if routes for explicit domains have been registered.
    * The boolean is computed after calling the "commit" method.
@@ -3827,9 +4037,27 @@ var Router = class extends LookupStore {
   get commited() {
     return this.#commited;
   }
+  /**
+   * Query string parser for making URLs
+   */
+  qs;
+  /**
+   * The URLBuilder offers a type-safe API for creating URL for pre-registered
+   * routes or the route patterns.
+   *
+   * We recommend using the URLBuilder over the "makeUrl" and "makeSignedUrl"
+   * methods.
+   */
+  urlBuilder;
   constructor(app, encryption, qsParser) {
-    super(encryption, qsParser);
+    super();
     this.#app = app;
+    this.#encryption = encryption;
+    this.qs = qsParser;
+    this.urlBuilder = {
+      urlFor: createUrlBuilder(this, this.qs.stringify),
+      signedUrlFor: createSignedUrlBuilder(this, this.#encryption, this.qs.stringify)
+    };
   }
   /**
    * Push a give router entity to the list of routes or the
@@ -3841,13 +4069,13 @@ var Router = class extends LookupStore {
       openedGroup.routes.push(entity);
       return;
     }
-    this.routes.push(entity);
+    this.#routesToBeCommitted.push(entity);
   }
   /**
    * Parses the route pattern
    */
   parsePattern(pattern, matchers) {
-    return parseRoutePattern(pattern, matchers);
+    return parseRoute(pattern, matchers);
   }
   /**
    * Define an array of middleware to use on all the routes.
@@ -3856,7 +4084,10 @@ var Router = class extends LookupStore {
    */
   use(middleware) {
     middleware.forEach(
-      (one) => this.#middleware.push(moduleImporter3(one, "handle").toHandleMethod())
+      (one) => this.#middleware.push({
+        reference: one,
+        ...moduleImporter3(one, "handle").toHandleMethod()
+      })
     );
     return this;
   }
@@ -3994,13 +4225,13 @@ var Router = class extends LookupStore {
     }
     debug_default("Committing routes to the routes store");
     const routeNamesByDomain = /* @__PURE__ */ new Map();
-    toRoutesJSON(this.routes).forEach((route) => {
+    toRoutesJSON(this.#routesToBeCommitted).forEach((route) => {
       if (!routeNamesByDomain.has(route.domain)) {
         routeNamesByDomain.set(route.domain, /* @__PURE__ */ new Set());
       }
       const routeNames = routeNamesByDomain.get(route.domain);
       if (route.name && routeNames.has(route.name)) {
-        throw new RuntimeException6(
+        throw new RuntimeException5(
           `Route with duplicate name found. A route with name "${route.name}" already exists`
         );
       }
@@ -4012,54 +4243,209 @@ var Router = class extends LookupStore {
     });
     routeNamesByDomain.clear();
     this.usingDomains = this.#store.usingDomains;
-    this.routes = [];
+    this.#routesToBeCommitted = [];
     this.#globalMatchers = {};
     this.#middleware = [];
+    this.#openedGroups = [];
     this.#commited = true;
   }
+  /**
+   * Generates types for the URL builder. These types must
+   * be written inside a file for the URL builder to
+   * pick them up.
+   */
+  generateTypes(indentation = 0) {
+    const routesList = {};
+    function trackRoute(route, domain) {
+      let params = [];
+      let paramsTuple = [];
+      let hasRequiredParams = false;
+      for (let token of route.tokens) {
+        if (token.type === 1) {
+          hasRequiredParams = true;
+          params.push(`'${token.val}': string`);
+          paramsTuple.push("string");
+        } else if (token.type === 3) {
+          params.push(`'${token.val}'?: string`);
+          paramsTuple.push("string?");
+        } else if (token.type === 2) {
+          hasRequiredParams = true;
+          params.push(`'*': string[]`);
+          paramsTuple.push("...string[]");
+          break;
+        }
+      }
+      route.methods.forEach((method) => {
+        routesList["ALL"] = routesList["ALL"] ?? {};
+        routesList[method] = routesList[method] ?? {};
+        const identifiers = [];
+        if (this.lookupStrategies.includes("pattern")) {
+          if (!routesList[method][route.pattern]) {
+            identifiers.push(route.pattern);
+          }
+        }
+        if (this.lookupStrategies.includes("name") && route.name) {
+          identifiers.push(
+            domain && routesList[method][route.name] ? `${domain}@${route.name}` : route.name
+          );
+        }
+        if (this.lookupStrategies.includes("controller") && "reference" in route.handler && typeof route.handler.reference === "string") {
+          identifiers.push(
+            domain && routesList[method][route.handler.reference] ? `${domain}@${route.handler.reference}` : route.handler.reference
+          );
+        }
+        identifiers.forEach((identifier) => {
+          routesList["ALL"][identifier] = {
+            params,
+            paramsTuple,
+            hasRequiredParams
+          };
+          routesList[method][identifier] = {
+            params,
+            paramsTuple,
+            hasRequiredParams
+          };
+        });
+      });
+    }
+    const domains = Object.keys(this.routes).filter((domain) => domain !== "root");
+    this.routes["root"].forEach((route) => trackRoute.bind(this)(route));
+    domains.forEach(
+      (domain) => this.routes[domain].forEach((route) => trackRoute.bind(this)(route, domain))
+    );
+    return Object.keys(routesList).reduce((result, method) => {
+      result.push(`${" ".repeat(indentation)}'${method}': {`);
+      Object.keys(routesList[method]).forEach((identifier) => {
+        const key = `'${identifier}'`;
+        const { paramsTuple, hasRequiredParams, params } = routesList[method][identifier];
+        const dictName = hasRequiredParams ? "params" : "params?";
+        const tupleName = hasRequiredParams ? "paramsTuple" : "paramsTuple?";
+        const dictValue = `{${params.join(",")}}`;
+        const tupleValue = `[${paramsTuple?.join(",")}]`;
+        const value = `{ ${tupleName}: ${tupleValue}, ${dictName}: ${dictValue} }`;
+        result.push(`${" ".repeat(indentation + 2)}${key}: ${value},`);
+      });
+      result.push(`${" ".repeat(indentation)}},`);
+      return result;
+    }, []).join("\n");
+  }
+  generateClient() {
+    const routesForClient = Object.keys(this.routes).reduce(
+      (result, domain) => {
+        const routes = this.routes[domain];
+        result[domain] = routes.map((route) => {
+          const controller = "reference" in route.handler && typeof route.handler.reference === "string" ? route.handler.reference : void 0;
+          return {
+            pattern: route.pattern,
+            name: route.name,
+            handler: {
+              reference: controller
+            },
+            methods: route.methods,
+            domain: route.domain,
+            tokens: route.tokens.map((tokens) => {
+              return lodash2.pick(tokens, ["val", "type", "end"]);
+            })
+          };
+        });
+        return result;
+      },
+      {}
+    );
+    return `import type { RoutesList } from '@adonisjs/core/types/http'
+import { RouterClient, createUrlBuilder, ClientRouteJSON } from 'adonisjs/core/http/client'
+
+const routes = ${JSON.stringify(routesForClient)} satisfies { [domain: string]: ClientRouteJSON[] }
+const router = new RouterClient(routes)
+export const urlFor = createUrlBuilder<RoutesList>(router, (qs) => {
+  return new URLSearchParams(qs).toString()
+})`;
+  }
   /**
    * Find route for a given URL, method and optionally domain
    */
-  match(url, method, hostname) {
+  match(uri, method, shouldDecodeParam, hostname) {
     const matchingDomain = this.#store.matchDomain(hostname);
-    return matchingDomain.length ? this.#store.match(url, method, {
+    return matchingDomain.length ? this.#store.match(uri, method, shouldDecodeParam, {
       tokens: matchingDomain,
       hostname
-    }) : this.#store.match(url, method);
+    }) : this.#store.match(uri, method, shouldDecodeParam);
+  }
+  /**
+   * Create URL builder instance.
+   * @deprecated
+   *
+   * Instead use "@adonisjs/core/services/url_builder" instead
+   */
+  builder() {
+    return new UrlBuilder(this);
+  }
+  /**
+   * Create URL builder instance for a given domain.
+   * @deprecated
+   *
+   * Instead use "@adonisjs/core/services/url_builder"
+   */
+  builderForDomain(domain) {
+    return new UrlBuilder(this, domain);
   }
   /**
    * Make URL to a pre-registered route
+   *
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder"
    */
   makeUrl(routeIdentifier, params, options) {
     const normalizedOptions = Object.assign({}, options);
-    const builder = normalizedOptions.domain ? this.builderForDomain(normalizedOptions.domain) : this.builder();
-    builder.params(params);
-    builder.qs(normalizedOptions.qs);
-    normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-    normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-    return builder.make(routeIdentifier);
+    if (options?.disableRouteLookup) {
+      return createURL(
+        routeIdentifier,
+        parseRoute(routeIdentifier),
+        this.qs.stringify,
+        params,
+        options
+      );
+    }
+    const route = this.findOrFail(routeIdentifier, normalizedOptions.domain);
+    return createURL(route.name ?? route.pattern, route.tokens, this.qs.stringify, params, options);
   }
   /**
    * Makes a signed URL to a pre-registered route.
+   *
+   * @deprecated
+   * Instead use "@adonisjs/core/services/url_builder"
    */
   makeSignedUrl(routeIdentifier, params, options) {
     const normalizedOptions = Object.assign({}, options);
-    const builder = normalizedOptions.domain ? this.builderForDomain(normalizedOptions.domain) : this.builder();
-    builder.params(params);
-    builder.qs(normalizedOptions.qs);
-    normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-    normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-    return builder.makeSigned(routeIdentifier, normalizedOptions);
+    if (options?.disableRouteLookup) {
+      return createSignedURL(
+        routeIdentifier,
+        parseRoute(routeIdentifier),
+        this.qs.stringify,
+        this.#encryption,
+        params,
+        options
+      );
+    }
+    const route = this.findOrFail(routeIdentifier, normalizedOptions.domain);
+    return createSignedURL(
+      route.name ?? route.pattern,
+      route.tokens,
+      this.qs.stringify,
+      this.#encryption,
+      params,
+      options
+    );
   }
 };
 
 // src/http_context/main.ts
-import { inspect } from "node:util";
-import Macroable9 from "@poppinss/macroable";
-import { RuntimeException as RuntimeException7 } from "@poppinss/utils";
+import { inspect } from "util";
+import Macroable8 from "@poppinss/macroable";
+import { RuntimeException as RuntimeException6 } from "@poppinss/utils/exception";
 
 // src/http_context/local_storage.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage } from "async_hooks";
 var asyncLocalStorage = {
   /**
    * Check if the async local storage for the HTTP
@@ -4089,7 +4475,7 @@ var asyncLocalStorage = {
 };
 
 // src/http_context/main.ts
-var HttpContext = class extends Macroable9 {
+var HttpContext = class extends Macroable8 {
   constructor(request, response, logger, containerResolver) {
     super();
     this.request = request;
@@ -4122,13 +4508,13 @@ var HttpContext = class extends Macroable9 {
    */
   static getOrFail() {
     if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
-      throw new RuntimeException7(
+      throw new RuntimeException6(
         'HTTP context is not available. Enable "useAsyncLocalStorage" inside "config/app.ts" file'
       );
     }
     const store = this.get();
     if (!store) {
-      throw new RuntimeException7("Http context is not available outside of an HTTP request");
+      throw new RuntimeException6("Http context is not available outside of an HTTP request");
     }
     return store;
   }
@@ -4174,27 +4560,27 @@ import Middleware2 from "@poppinss/middleware";
 import { moduleCaller as moduleCaller2, moduleImporter as moduleImporter4 } from "@adonisjs/fold";
 
 // src/qs.ts
-import { parse as parse3, stringify } from "qs";
+import { parse as parse2, stringify } from "qs";
 var Qs = class {
   #config;
   constructor(config) {
     this.#config = config;
   }
-  parse(value) {
-    return parse3(value, this.#config.parse);
-  }
-  stringify(value) {
+  parse = (value) => {
+    return parse2(value, this.#config.parse);
+  };
+  stringify = (value) => {
     return stringify(value, this.#config.stringify);
-  }
+  };
 };
 
-// src/server/factories/final_handler.ts
-function finalHandler(router, resolver, ctx, errorResponder) {
+// src/server/factories/route_finder.ts
+function routeFinder(router, resolver, ctx, errorResponder) {
   return function() {
     const url = ctx.request.url();
     const method = ctx.request.method();
     const hostname = router.usingDomains ? ctx.request.hostname() : void 0;
-    const route = router.match(url, method, hostname);
+    const route = router.match(url, method, ctx.request.parsedUrl.shouldDecodeParam, hostname);
     if (route) {
       ctx.params = route.params;
       ctx.subdomains = route.subdomains;
@@ -4223,7 +4609,14 @@ function writeResponse(ctx) {
 function middlewareHandler(resolver, ctx) {
   return function(fn, next) {
     debug_default("executing middleware %s", fn.name);
-    return fn.handle(resolver, ctx, next);
+    return httpMiddleware.tracePromise(
+      fn.handle,
+      fn,
+      void 0,
+      resolver,
+      ctx,
+      next
+    );
   };
 }
 
@@ -4301,7 +4694,13 @@ var Server = class {
    */
   #requestErrorResponder = (error, ctx) => {
     this.#resolvedErrorHandler.report(error, ctx);
-    return this.#resolvedErrorHandler.handle(error, ctx);
+    return httpExceptionHandler.tracePromise(
+      this.#resolvedErrorHandler.handle,
+      void 0,
+      void 0,
+      error,
+      ctx
+    );
   };
   /**
    * Check if the server has already been booted
@@ -4350,7 +4749,7 @@ var Server = class {
    * Handles the HTTP request
    */
   #handleRequest(ctx, resolver) {
-    return this.#serverMiddlewareStack.runner().errorHandler((error) => this.#requestErrorResponder(error, ctx)).finalHandler(finalHandler(this.#router, resolver, ctx, this.#requestErrorResponder)).run(middlewareHandler(resolver, ctx)).catch((error) => {
+    return this.#serverMiddlewareStack.runner().errorHandler((error) => this.#requestErrorResponder(error, ctx)).finalHandler(routeFinder(this.#router, resolver, ctx, this.#requestErrorResponder)).run(middlewareHandler(resolver, ctx)).catch((error) => {
       ctx.logger.fatal({ err: error }, "Exception raised by error handler");
       return this.#defaultErrorHandler.handle(error, ctx);
     }).finally(writeResponse(ctx));
@@ -4361,7 +4760,10 @@ var Server = class {
   pipeline(middleware) {
     const middlewareStack = new Middleware2();
     middleware.forEach((one) => {
-      middlewareStack.add(moduleCaller2(one, "handle").toHandleMethod());
+      middlewareStack.add({
+        reference: one,
+        ...moduleCaller2(one, "handle").toHandleMethod()
+      });
     });
     middlewareStack.freeze();
     const stackRunner = middlewareStack.runner();
@@ -4388,7 +4790,10 @@ var Server = class {
    */
   use(middleware) {
     middleware.forEach(
-      (one) => this.#middleware.push(moduleImporter4(one, "handle").toHandleMethod())
+      (one) => this.#middleware.push({
+        reference: one,
+        ...moduleImporter4(one, "handle").toHandleMethod()
+      })
     );
     return this;
   }
@@ -4469,6 +4874,12 @@ var Server = class {
       resolver
     );
   }
+  /**
+   * Returns a list of server middleware stack
+   */
+  getMiddlewareList() {
+    return this.#serverMiddlewareStack ? Array.from(this.#serverMiddlewareStack.all()) : [...this.#middleware];
+  }
   /**
    * Handle request
    */
@@ -4490,15 +4901,18 @@ var Server = class {
       });
     }
     if (this.usingAsyncLocalStorage) {
-      return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));
+      return asyncLocalStorage.storage.run(
+        ctx,
+        () => httpRequest.tracePromise(this.#handleRequest, ctx, this, ctx, resolver)
+      );
     }
-    return this.#handleRequest(ctx, resolver);
+    return httpRequest.tracePromise(this.#handleRequest, ctx, this, ctx, resolver);
   }
 };
 
 // src/define_config.ts
 import proxyAddr from "proxy-addr";
-import string3 from "@poppinss/utils/string";
+import string2 from "@poppinss/utils/string";
 import lodash3 from "@poppinss/utils/lodash";
 function defineConfig(config) {
   const { trustProxy: trustProxy2, ...rest } = config;
@@ -4506,7 +4920,10 @@ function defineConfig(config) {
     allowMethodSpoofing: false,
     trustProxy: proxyAddr.compile("loopback"),
     subdomainOffset: 2,
-    generateRequestId: false,
+    generateRequestId: !!config.createRequestId,
+    createRequestId() {
+      return crypto.randomUUID();
+    },
     useAsyncLocalStorage: false,
     etag: false,
     jsonpCallbackName: "callback",
@@ -4535,7 +4952,7 @@ function defineConfig(config) {
   };
   const normalizedConfig = lodash3.merge({}, defaults, rest);
   if (normalizedConfig.cookie.maxAge) {
-    normalizedConfig.cookie.maxAge = string3.seconds.parse(normalizedConfig.cookie.maxAge);
+    normalizedConfig.cookie.maxAge = string2.seconds.parse(normalizedConfig.cookie.maxAge);
   }
   if (typeof trustProxy2 === "boolean") {
     const tpValue = trustProxy2;
@@ -4550,19 +4967,21 @@ function defineConfig(config) {
 }
 
 export {
+  E_ROUTE_NOT_FOUND,
+  E_CANNOT_LOOKUP_ROUTE,
+  E_HTTP_EXCEPTION,
+  E_HTTP_REQUEST_ABORTED,
+  errors_exports,
+  CookieClient,
+  canWriteResponseBody,
+  tracing_channels_exports,
   Route,
   BriskRoute,
   RouteResource,
   RouteGroup,
   parseRange,
-  CookieClient,
   Request,
   Redirect,
-  E_ROUTE_NOT_FOUND,
-  E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED,
-  exceptions_exports,
   ResponseStatus,
   Response,
   Qs,
@@ -4571,4 +4990,3 @@ export {
   Server,
   defineConfig
 };
-//# sourceMappingURL=chunk-7AGINHO3.js.map