shokupan 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const api = require("@opentelemetry/api");
 const eta$2 = require("eta");
 const promises = require("fs/promises");
 const path = require("path");
 const node_async_hooks = require("node:async_hooks");
+const api = require("@opentelemetry/api");
 const arctic = require("arctic");
 const jose = require("jose");
-const openapiAnalyzer = require("./openapi-analyzer-CFqgSLNK.cjs");
-const crypto = require("crypto");
-const events = require("events");
+const Ajv = require("ajv");
+const addFormats = require("ajv-formats");
 const classTransformer = require("class-transformer");
 const classValidator = require("class-validator");
+const openapiAnalyzer = require("./openapi-analyzer-BN0wFCML.cjs");
+const crypto = require("crypto");
+const events = require("events");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -30,12 +32,13 @@ function _interopNamespaceDefault(e) {
 }
 const jose__namespace = /* @__PURE__ */ _interopNamespaceDefault(jose);
 class ShokupanResponse {
-  _headers = new Headers();
+  _headers = null;
   _status = 200;
   /**
    * Get the current headers
    */
   get headers() {
+    if (!this._headers) this._headers = new Headers();
     return this._headers;
   }
   /**
@@ -56,6 +59,7 @@ class ShokupanResponse {
    * @param value Header value
    */
   set(key, value) {
+    if (!this._headers) this._headers = new Headers();
     this._headers.set(key, value);
     return this;
   }
@@ -65,6 +69,7 @@ class ShokupanResponse {
    * @param value Header value
    */
   append(key, value) {
+    if (!this._headers) this._headers = new Headers();
     this._headers.append(key, value);
     return this;
   }
@@ -73,29 +78,58 @@ class ShokupanResponse {
    * @param key Header name
    */
   get(key) {
-    return this._headers.get(key);
+    return this._headers?.get(key) || null;
   }
   /**
    * Check if a header exists
    * @param key Header name
    */
   has(key) {
-    return this._headers.has(key);
+    return this._headers?.has(key) || false;
+  }
+  /**
+   * Internal: check if headers have been initialized/modified
+   */
+  get hasPopulatedHeaders() {
+    return this._headers !== null;
   }
 }
 class ShokupanContext {
-  constructor(request, server, state, app) {
+  constructor(request, server, state, app, enableMiddlewareTracking = false) {
     this.request = request;
     this.server = server;
     this.app = app;
-    this.url = new URL(request.url);
     this.state = state || {};
+    if (enableMiddlewareTracking) {
+      const self = this;
+      this.state = new Proxy(this.state, {
+        set(target, p, newValue, receiver) {
+          const result = Reflect.set(target, p, newValue, receiver);
+          const currentHandler = self.handlerStack[self.handlerStack.length - 1];
+          if (currentHandler) {
+            if (!currentHandler.stateChanges) currentHandler.stateChanges = {};
+            currentHandler.stateChanges[p] = newValue;
+          }
+          return result;
+        }
+      });
+    }
     this.response = new ShokupanResponse();
   }
-  url;
+  _url;
   params = {};
+  // Router assigns this, but default to empty object
   state;
+  handlerStack = [];
   response;
+  _finalResponse;
+  get url() {
+    if (!this._url) {
+      const urlString = this.request.url || "http://localhost/";
+      this._url = new URL(urlString);
+    }
+    return this._url;
+  }
   /**
    * Base request
    */
@@ -112,7 +146,26 @@ class ShokupanContext {
    * Request path
    */
   get path() {
-    return this.url.pathname;
+    if (this._url) return this._url.pathname;
+    const url = this.request.url;
+    let queryIndex = url.indexOf("?");
+    const end = queryIndex === -1 ? url.length : queryIndex;
+    let start = 0;
+    const protocolIndex = url.indexOf("://");
+    if (protocolIndex !== -1) {
+      const hostStart = protocolIndex + 3;
+      const pathStart = url.indexOf("/", hostStart);
+      if (pathStart !== -1 && pathStart < end) {
+        start = pathStart;
+      } else {
+        return "/";
+      }
+    } else {
+      if (url.charCodeAt(0) === 47) {
+        start = 0;
+      }
+    }
+    return url.substring(start, end);
   }
   /**
    * Request query params
@@ -209,9 +262,25 @@ class ShokupanContext {
     return this;
   }
   mergeHeaders(headers) {
-    const h = new Headers(this.response.headers);
+    let h;
+    if (this.response.hasPopulatedHeaders) {
+      h = new Headers(this.response.headers);
+    } else {
+      h = new Headers();
+    }
     if (headers) {
-      new Headers(headers).forEach((v, k) => h.set(k, v));
+      if (headers instanceof Headers) {
+        headers.forEach((v, k) => h.set(k, v));
+      } else if (Array.isArray(headers)) {
+        headers.forEach(([k, v]) => h.set(k, v));
+      } else {
+        const keys = Object.keys(headers);
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          const val = headers[key];
+          h.set(key, val);
+        }
+      }
     }
     return h;
   }
@@ -224,7 +293,8 @@ class ShokupanContext {
   send(body, options) {
     const headers = this.mergeHeaders(options?.headers);
     const status = options?.status ?? this.response.status;
-    return new Response(body, { status, headers });
+    this._finalResponse = new Response(body, { status, headers });
+    return this._finalResponse;
   }
   /**
    * Read request body
@@ -243,19 +313,36 @@ class ShokupanContext {
    * Respond with a JSON object
    */
   json(data, status, headers) {
+    const finalStatus = status ?? this.response.status;
+    const jsonString = JSON.stringify(data);
+    if (!headers && !this.response.hasPopulatedHeaders) {
+      this._finalResponse = new Response(jsonString, {
+        status: finalStatus,
+        headers: { "content-type": "application/json" }
+      });
+      return this._finalResponse;
+    }
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "application/json");
-    const finalStatus = status ?? this.response.status;
-    return new Response(JSON.stringify(data), { status: finalStatus, headers: finalHeaders });
+    this._finalResponse = new Response(jsonString, { status: finalStatus, headers: finalHeaders });
+    return this._finalResponse;
   }
   /**
    * Respond with a text string
    */
   text(data, status, headers) {
+    const finalStatus = status ?? this.response.status;
+    if (!headers && !this.response.hasPopulatedHeaders) {
+      this._finalResponse = new Response(data, {
+        status: finalStatus,
+        headers: { "content-type": "text/plain" }
+      });
+      return this._finalResponse;
+    }
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "text/plain");
-    const finalStatus = status ?? this.response.status;
-    return new Response(data, { status: finalStatus, headers: finalHeaders });
+    this._finalResponse = new Response(data, { status: finalStatus, headers: finalHeaders });
+    return this._finalResponse;
   }
   /**
    * Respond with HTML content
@@ -264,7 +351,8 @@ class ShokupanContext {
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "text/html");
     const finalStatus = status ?? this.response.status;
-    return new Response(html, { status: finalStatus, headers: finalHeaders });
+    this._finalResponse = new Response(html, { status: finalStatus, headers: finalHeaders });
+    return this._finalResponse;
   }
   /**
    * Respond with a redirect
@@ -272,7 +360,8 @@ class ShokupanContext {
   redirect(url, status = 302) {
     const headers = this.mergeHeaders();
     headers.set("Location", url);
-    return new Response(null, { status, headers });
+    this._finalResponse = new Response(null, { status, headers });
+    return this._finalResponse;
   }
   /**
    * Respond with a status code
@@ -280,7 +369,8 @@ class ShokupanContext {
    */
   status(status) {
     const headers = this.mergeHeaders();
-    return new Response(null, { status, headers });
+    this._finalResponse = new Response(null, { status, headers });
+    return this._finalResponse;
   }
   /**
    * Respond with a file
@@ -288,7 +378,8 @@ class ShokupanContext {
   file(path2, fileOptions, responseOptions) {
     const headers = this.mergeHeaders(responseOptions?.headers);
     const status = responseOptions?.status ?? this.response.status;
-    return new Response(Bun.file(path2, fileOptions), { status, headers });
+    this._finalResponse = new Response(Bun.file(path2, fileOptions), { status, headers });
+    return this._finalResponse;
   }
   /**
    * JSX Rendering Function
@@ -437,69 +528,29 @@ function Inject(token) {
     });
   };
 }
-const tracer = api.trace.getTracer("shokupan.middleware");
-function traceMiddleware(fn, name) {
-  const middlewareName = fn.name || "anonymous middleware";
-  return async (ctx, next) => {
-    return tracer.startActiveSpan(`middleware - ${middlewareName}`, {
-      kind: api.SpanKind.INTERNAL,
-      attributes: {
-        "code.function": middlewareName,
-        "component": "shokupan.middleware"
-      }
-    }, async (span) => {
-      try {
-        const result = await fn(ctx, next);
-        return result;
-      } catch (err) {
-        span.recordException(err);
-        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
-        throw err;
-      } finally {
-        span.end();
-      }
-    });
-  };
-}
-function traceHandler(fn, name) {
-  return async function(...args) {
-    return tracer.startActiveSpan(`route handler - ${name}`, {
-      kind: api.SpanKind.INTERNAL,
-      attributes: {
-        "http.route": name,
-        "component": "shokupan.route"
+const compose = (middleware) => {
+  if (!middleware.length) {
+    return (context, next) => {
+      return next ? next() : Promise.resolve();
+    };
+  }
+  return function dispatch(context, next) {
+    let index = -1;
+    function runner(i) {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      if (i >= middleware.length) {
+        return next ? next() : Promise.resolve();
       }
-    }, async (span) => {
+      const fn = middleware[i];
       try {
-        const result = await fn.apply(this, args);
-        return result;
+        return Promise.resolve(fn(context, () => runner(i + 1)));
       } catch (err) {
-        span.recordException(err);
-        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
-        throw err;
-      } finally {
-        span.end();
+        return Promise.reject(err);
       }
-    });
-  };
-}
-const compose = (middleware) => {
-  function fn(context, next) {
-    let runner = next || (async () => {
-    });
-    for (let i = middleware.length - 1; i >= 0; i--) {
-      const fn2 = traceMiddleware(middleware[i]);
-      const nextStep = runner;
-      let called = false;
-      runner = async () => {
-        if (called) throw new Error("next() called multiple times");
-        called = true;
-        return fn2(context, nextStep);
-      };
     }
-    return runner();
-  }
-  return fn;
+    return runner(0);
+  };
 };
 class ShokupanRequestBase {
   method;
@@ -726,7 +777,7 @@ async function generateOpenApi(rootRouter, options = {}) {
   const defaultTagName = options.defaultTag || "Application";
   let astRoutes = [];
   try {
-    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./openapi-analyzer-CFqgSLNK.cjs"));
+    const { OpenAPIAnalyzer } = await Promise.resolve().then(() => require("./openapi-analyzer-BN0wFCML.cjs"));
     const analyzer = new OpenAPIAnalyzer(process.cwd());
     const { applications } = await analyzer.analyze();
     const appMap = /* @__PURE__ */ new Map();
@@ -1126,6 +1177,29 @@ function serveStatic(ctx, config, prefix) {
   };
 }
 const asyncContext = new node_async_hooks.AsyncLocalStorage();
+const tracer = api.trace.getTracer("shokupan.middleware");
+function traceHandler(fn, name) {
+  return async function(...args) {
+    return tracer.startActiveSpan(`route handler - ${name}`, {
+      kind: api.SpanKind.INTERNAL,
+      attributes: {
+        "http.route": name,
+        "component": "shokupan.route"
+      }
+    }, async (span) => {
+      try {
+        const result = await fn.apply(this, args);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
 const RouterRegistry = /* @__PURE__ */ new Map();
 const ShokupanApplicationTree = {};
 class ShokupanRouter {
@@ -1316,7 +1390,7 @@ class ShokupanRouter {
                 }
               }
             }
-            const tracedOriginalHandler = traceHandler(originalHandler, normalizedPath);
+            const tracedOriginalHandler = ctx.app?.applicationConfig.enableTracing ? traceHandler(originalHandler, normalizedPath) : originalHandler;
             return tracedOriginalHandler.apply(instance, args);
           };
           let finalHandler = wrappedHandler;
@@ -1452,6 +1526,7 @@ class ShokupanRouter {
   applyHooks(match) {
     if (!this.config?.hooks) return match;
     const hooks = this.config.hooks;
+    if (!hooks.onRequestStart && !hooks.onRequestEnd && !hooks.onError) return match;
     const originalHandler = match.handler;
     match.handler = async (ctx) => {
       if (hooks.onRequestStart) await hooks.onRequestStart(ctx);
@@ -1480,16 +1555,25 @@ class ShokupanRouter {
    * @returns Route handler and parameters if found, otherwise null
    */
   find(method, path2) {
-    for (const route of this[$routes]) {
-      if (route.method !== "ALL" && route.method !== method) continue;
-      const match = route.regex.exec(path2);
-      if (match) {
-        const params = {};
-        route.keys.forEach((key, index) => {
-          params[key] = match[index + 1];
-        });
-        return this.applyHooks({ handler: route.handler, params });
+    const findInRoutes = (routes, m) => {
+      for (const route of routes) {
+        if (route.method !== "ALL" && route.method !== m) continue;
+        const match = route.regex.exec(path2);
+        if (match) {
+          const params = {};
+          route.keys.forEach((key, index) => {
+            params[key] = match[index + 1];
+          });
+          return this.applyHooks({ handler: route.handler, params });
+        }
       }
+      return null;
+    };
+    let result = findInRoutes(this[$routes], method);
+    if (result) return result;
+    if (method === "HEAD") {
+      result = findInRoutes(this[$routes], "GET");
+      if (result) return result;
     }
     for (const child of this[$childRouters]) {
       const prefix = child[$mountPath];
@@ -1582,6 +1666,35 @@ class ShokupanRouter {
         return innerHandler(ctx);
       };
     }
+    let file = "unknown";
+    let line = 0;
+    try {
+      const err = new Error();
+      const stack = err.stack?.split("\n") || [];
+      const callerLine = stack.find(
+        (l) => l.includes(":") && !l.includes("router.ts") && !l.includes("shokupan.ts") && !l.includes("node_modules") && !l.includes("bun:main")
+      );
+      if (callerLine) {
+        const match = callerLine.match(/\((.*):(\d+):(\d+)\)/) || callerLine.match(/at (.*):(\d+):(\d+)/);
+        if (match) {
+          file = match[1];
+          line = parseInt(match[2], 10);
+        }
+      }
+    } catch (e) {
+    }
+    const trackedHandler = wrappedHandler;
+    wrappedHandler = async (ctx) => {
+      if (ctx.app?.applicationConfig.enableMiddlewareTracking) {
+        ctx.handlerStack.push({
+          name: handler.name || "anonymous",
+          file,
+          line
+        });
+      }
+      return trackedHandler(ctx);
+    };
+    wrappedHandler.originalHandler = trackedHandler.originalHandler || trackedHandler;
     this[$routes].push({
       method,
       path: path2,
@@ -1627,7 +1740,35 @@ class ShokupanRouter {
   guard(specOrHandler, handler) {
     const spec = typeof specOrHandler === "function" ? void 0 : specOrHandler;
     const guardHandler = typeof specOrHandler === "function" ? specOrHandler : handler;
-    this.currentGuards.push({ handler: guardHandler, spec });
+    let file = "unknown";
+    let line = 0;
+    try {
+      const err = new Error();
+      const stack = err.stack?.split("\n") || [];
+      const callerLine = stack.find(
+        (l) => l.includes(":") && !l.includes("router.ts") && !l.includes("shokupan.ts") && !l.includes("node_modules") && !l.includes("bun:main")
+      );
+      if (callerLine) {
+        const match = callerLine.match(/\((.*):(\d+):(\d+)\)/) || callerLine.match(/at (.*):(\d+):(\d+)/);
+        if (match) {
+          file = match[1];
+          line = parseInt(match[2], 10);
+        }
+      }
+    } catch (e) {
+    }
+    const trackedGuard = async (ctx, next) => {
+      if (ctx.app?.applicationConfig.enableMiddlewareTracking) {
+        ctx.handlerStack.push({
+          name: guardHandler.name || "guard",
+          file,
+          line
+        });
+      }
+      return guardHandler(ctx, next);
+    };
+    trackedGuard.originalHandler = guardHandler.originalHandler || guardHandler;
+    this.currentGuards.push({ handler: trackedGuard, spec });
     return this;
   }
   /**
@@ -1715,6 +1856,7 @@ class Shokupan extends ShokupanRouter {
   applicationConfig = {};
   openApiSpec;
   middleware = [];
+  composedMiddleware;
   get logger() {
     return this.applicationConfig.logger;
   }
@@ -1728,7 +1870,37 @@ class Shokupan extends ShokupanRouter {
    * Adds middleware to the application.
    */
   use(middleware) {
-    this.middleware.push(middleware);
+    let trackedMiddleware = middleware;
+    let file = "unknown";
+    let line = 0;
+    try {
+      const err = new Error();
+      const stack = err.stack?.split("\n") || [];
+      const callerLine = stack.find(
+        (l) => l.includes(":") && !l.includes("shokupan.ts") && !l.includes("router.ts") && // In case called from router?
+        !l.includes("node_modules") && !l.includes("bun:main")
+      );
+      if (callerLine) {
+        const match = callerLine.match(/\((.*):(\d+):(\d+)\)/) || callerLine.match(/at (.*):(\d+):(\d+)/);
+        if (match) {
+          file = match[1];
+          line = parseInt(match[2], 10);
+        }
+      }
+    } catch (e) {
+    }
+    trackedMiddleware = async (ctx, next) => {
+      const c = ctx;
+      if (c.handlerStack && c.app?.applicationConfig.enableMiddlewareTracking) {
+        c.handlerStack.push({
+          name: middleware.name || "middleware",
+          file,
+          line
+        });
+      }
+      return middleware(ctx, next);
+    };
+    this.middleware.push(trackedMiddleware);
     return this;
   }
   startupHooks = [];
@@ -1763,9 +1935,28 @@ class Shokupan extends ShokupanRouter {
       development: this.applicationConfig.development,
       fetch: this.fetch.bind(this),
       reusePort: this.applicationConfig.reusePort,
-      idleTimeout: this.applicationConfig.readTimeout ? this.applicationConfig.readTimeout / 1e3 : void 0
+      idleTimeout: this.applicationConfig.readTimeout ? this.applicationConfig.readTimeout / 1e3 : void 0,
+      websocket: {
+        open(ws) {
+          ws.data?.handler?.open?.(ws);
+        },
+        message(ws, message) {
+          ws.data?.handler?.message?.(ws, message);
+        },
+        drain(ws) {
+          ws.data?.handler?.drain?.(ws);
+        },
+        close(ws, code, reason) {
+          ws.data?.handler?.close?.(ws, code, reason);
+        }
+      }
     };
-    const server = this.applicationConfig.serverFactory ? await this.applicationConfig.serverFactory(serveOptions) : Bun.serve(serveOptions);
+    let factory = this.applicationConfig.serverFactory;
+    if (!factory && typeof Bun === "undefined") {
+      const { createHttpServer } = await Promise.resolve().then(() => require("./server-adapter-BD6oKEto.cjs"));
+      factory = createHttpServer();
+    }
+    const server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
     console.log(`Shokupan server listening on http://${server.hostname}:${server.port}`);
     return server;
   }
@@ -1820,108 +2011,118 @@ class Shokupan extends ShokupanRouter {
    * @returns The response to send.
    */
   async fetch(req, server) {
-    const tracer2 = api.trace.getTracer("shokupan.application");
-    const store = asyncContext.getStore();
-    const attrs = {
-      attributes: {
-        "http.url": req.url,
-        "http.method": req.method
-      }
-    };
-    const parent = store?.get("span");
-    const ctx = parent ? api.trace.setSpan(api.context.active(), parent) : void 0;
-    return tracer2.startActiveSpan(`${req.method} ${new URL(req.url).pathname}`, attrs, ctx, (span) => {
+    if (this.applicationConfig.enableTracing) {
+      const tracer2 = api.trace.getTracer("shokupan.application");
+      const store = asyncContext.getStore();
+      const attrs = {
+        attributes: {
+          "http.url": req.url,
+          "http.method": req.method
+        }
+      };
+      const parent = store?.get("span");
+      const ctx = parent ? api.trace.setSpan(api.context.active(), parent) : void 0;
+      return tracer2.startActiveSpan(`${req.method} ${new URL(req.url).pathname}`, attrs, ctx, (span) => {
+        const ctxMap = /* @__PURE__ */ new Map();
+        ctxMap.set("span", span);
+        ctxMap.set("request", req);
+        return asyncContext.run(ctxMap, () => this.handleRequest(req, server).finally(() => span.end()));
+      });
+    }
+    if (this.applicationConfig.enableAsyncLocalStorage) {
       const ctxMap = /* @__PURE__ */ new Map();
-      ctxMap.set("span", span);
       ctxMap.set("request", req);
-      const runCallback = () => {
-        const request = req;
-        const ctx2 = new ShokupanContext(request, server, void 0, this);
-        const handle = async () => {
-          try {
-            if (this.applicationConfig.hooks?.onRequestStart) {
-              await this.applicationConfig.hooks.onRequestStart(ctx2);
-            }
-            const fn = compose(this.middleware);
-            const result = await fn(ctx2, async () => {
-              const match = this.find(req.method, ctx2.path);
-              if (match) {
-                ctx2.params = match.params;
-                return match.handler(ctx2);
-              }
-              return null;
-            });
-            let response;
-            if (result instanceof Response) {
-              response = result;
-            } else if (result === null || result === void 0) {
-              span.setAttribute("http.status_code", 404);
-              response = ctx2.text("Not Found", 404);
-            } else if (typeof result === "object") {
-              response = ctx2.json(result);
-            } else {
-              response = ctx2.text(String(result));
-            }
-            if (this.applicationConfig.hooks?.onRequestEnd) {
-              await this.applicationConfig.hooks.onRequestEnd(ctx2);
-            }
-            if (this.applicationConfig.hooks?.onResponseStart) {
-              await this.applicationConfig.hooks.onResponseStart(ctx2, response);
-            }
-            return response;
-          } catch (err) {
-            console.error(err);
-            span.recordException(err);
-            span.setStatus({ code: 2 });
-            const status = err.status || err.statusCode || 500;
-            const body = { error: err.message || "Internal Server Error" };
-            if (err.errors) body.errors = err.errors;
-            if (this.applicationConfig.hooks?.onError) {
-              try {
-                await this.applicationConfig.hooks.onError(err, ctx2);
-              } catch (hookErr) {
-                console.error("Error in onError hook:", hookErr);
-              }
-            }
-            return ctx2.json(body, status);
+      return asyncContext.run(ctxMap, () => this.handleRequest(req, server));
+    }
+    return this.handleRequest(req, server);
+  }
+  async handleRequest(req, server) {
+    const request = req;
+    const ctx = new ShokupanContext(request, server, void 0, this, this.applicationConfig.enableMiddlewareTracking);
+    const handle = async () => {
+      try {
+        if (this.applicationConfig.hooks?.onRequestStart) {
+          await this.applicationConfig.hooks.onRequestStart(ctx);
+        }
+        const fn = this.composedMiddleware ??= compose(this.middleware);
+        const result = await fn(ctx, async () => {
+          const match = this.find(req.method, ctx.path);
+          if (match) {
+            ctx.params = match.params;
+            return match.handler(ctx);
           }
-        };
-        let executionPromise = handle();
-        const timeoutMs = this.applicationConfig.requestTimeout;
-        if (timeoutMs && timeoutMs > 0 && this.applicationConfig.hooks?.onRequestTimeout) {
-          let timeoutId;
-          const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout(async () => {
-              try {
-                if (this.applicationConfig.hooks?.onRequestTimeout) {
-                  await this.applicationConfig.hooks.onRequestTimeout(ctx2);
-                }
-              } catch (e) {
-                console.error("Error in onRequestTimeout hook:", e);
-              }
-              reject(new Error("Request Timeout"));
-            }, timeoutMs);
-          });
-          executionPromise = Promise.race([executionPromise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
+          return null;
+        });
+        let response;
+        if (result instanceof Response) {
+          response = result;
+        } else if ((result === null || result === void 0) && ctx._finalResponse instanceof Response) {
+          response = ctx._finalResponse;
+        } else if ((result === null || result === void 0) && ctx.response.status === 404) {
+          const span = asyncContext.getStore()?.get("span");
+          if (span) span.setAttribute("http.status_code", 404);
+          response = ctx.text("Not Found", 404);
+        } else if (result === null || result === void 0) {
+          if (ctx._finalResponse) response = ctx._finalResponse;
+          else response = ctx.text("Not Found", 404);
+        } else if (typeof result === "object") {
+          response = ctx.json(result);
+        } else {
+          response = ctx.text(String(result));
+        }
+        if (this.applicationConfig.hooks?.onRequestEnd) {
+          await this.applicationConfig.hooks.onRequestEnd(ctx);
         }
-        return executionPromise.catch((err) => {
-          if (err.message === "Request Timeout") {
-            return ctx2.text("Request Timeout", 408);
+        if (this.applicationConfig.hooks?.onResponseStart) {
+          await this.applicationConfig.hooks.onResponseStart(ctx, response);
+        }
+        return response;
+      } catch (err) {
+        console.error(err);
+        const span = asyncContext.getStore()?.get("span");
+        if (span) span.setStatus({ code: 2 });
+        const status = err.status || err.statusCode || 500;
+        const body = { error: err.message || "Internal Server Error" };
+        if (err.errors) body.errors = err.errors;
+        if (this.applicationConfig.hooks?.onError) {
+          try {
+            await this.applicationConfig.hooks.onError(err, ctx);
+          } catch (hookErr) {
+            console.error("Error in onError hook:", hookErr);
           }
-          console.error("Unexpected error in request execution:", err);
-          return ctx2.text("Internal Server Error", 500);
-        }).then(async (res) => {
-          if (this.applicationConfig.hooks?.onResponseEnd) {
-            await this.applicationConfig.hooks.onResponseEnd(ctx2, res);
+        }
+        return ctx.json(body, status);
+      }
+    };
+    let executionPromise = handle();
+    const timeoutMs = this.applicationConfig.requestTimeout;
+    if (timeoutMs && timeoutMs > 0 && this.applicationConfig.hooks?.onRequestTimeout) {
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(async () => {
+          try {
+            if (this.applicationConfig.hooks?.onRequestTimeout) {
+              await this.applicationConfig.hooks.onRequestTimeout(ctx);
+            }
+          } catch (e) {
+            console.error("Error in onRequestTimeout hook:", e);
           }
-          return res;
-        }).finally(() => span.end());
-      };
-      if (this.applicationConfig.enableAsyncLocalStorage) {
-        return asyncContext.run(ctxMap, runCallback);
-      } else {
-        return runCallback();
+          reject(new Error("Request Timeout"));
+        }, timeoutMs);
+      });
+      executionPromise = Promise.race([executionPromise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
+    }
+    return executionPromise.catch((err) => {
+      if (err.message === "Request Timeout") {
+        return ctx.text("Request Timeout", 408);
+      }
+      console.error("Unexpected error in request execution:", err);
+      return ctx.text("Internal Server Error", 500);
+    }).then(async (res) => {
+      if (this.applicationConfig.hooks?.onResponseEnd) {
+        await this.applicationConfig.hooks.onResponseEnd(ctx, res);
       }
+      return res;
     });
   }
 }
@@ -2148,15 +2349,19 @@ class AuthPlugin extends ShokupanRouter {
   }
 }
 function Compression(options = {}) {
-  const threshold = options.threshold ?? 1024;
+  const threshold = options.threshold ?? 512;
   return async (ctx, next) => {
     const acceptEncoding = ctx.headers.get("accept-encoding") || "";
     let method = null;
     if (acceptEncoding.includes("br")) method = "br";
+    else if (acceptEncoding.includes("zstd")) method = "zstd";
     else if (acceptEncoding.includes("gzip")) method = "gzip";
     else if (acceptEncoding.includes("deflate")) method = "deflate";
     if (!method) return next();
-    const response = await next();
+    let response = await next();
+    if (!(response instanceof Response) && ctx._finalResponse instanceof Response) {
+      response = ctx._finalResponse;
+    }
     if (response instanceof Response) {
       if (response.headers.has("Content-Encoding")) return response;
       const body = await response.arrayBuffer();
@@ -2168,17 +2373,31 @@ function Compression(options = {}) {
         });
       }
       let compressed;
-      if (method === "br") {
-        compressed = require("node:zlib").brotliCompressSync(body);
-      } else if (method === "gzip") {
-        compressed = Bun.gzipSync(body);
-      } else {
-        compressed = Bun.deflateSync(body);
+      switch (method) {
+        case "br":
+          const zlib = require("node:zlib");
+          compressed = await new Promise((res, rej) => zlib.brotliCompress(body, {
+            params: {
+              [zlib.constants.BROTLI_PARAM_QUALITY]: 4
+            }
+          }, (err, data) => {
+            if (err) return rej(err);
+            res(data);
+          }));
+          break;
+        case "gzip":
+          compressed = Bun.gzipSync(body);
+          break;
+        case "zstd":
+          compressed = await Bun.zstdCompress(body);
+          break;
+        default:
+          compressed = Bun.deflateSync(body);
+          break;
       }
       const headers = new Headers(response.headers);
       headers.set("Content-Encoding", method);
       headers.set("Content-Length", String(compressed.length));
-      headers.delete("Content-Length");
       return new Response(compressed, {
         status: response.status,
         statusText: response.statusText,
@@ -2319,72 +2538,407 @@ function useExpress(expressMiddleware) {
     });
   };
 }
-function RateLimit(options = {}) {
-  const windowMs = options.windowMs || 60 * 1e3;
-  const max = options.max || 5;
-  const message = options.message || "Too many requests, please try again later.";
-  const statusCode = options.statusCode || 429;
-  const headers = options.headers !== false;
-  const keyGenerator = options.keyGenerator || ((ctx) => {
-    return ctx.headers.get("x-forwarded-for") || ctx.url.hostname || "unknown";
-  });
-  const skip = options.skip || (() => false);
-  const hits = /* @__PURE__ */ new Map();
-  const interval = setInterval(() => {
-    const now = Date.now();
-    for (const [key, record] of hits.entries()) {
-      if (record.resetTime <= now) {
-        hits.delete(key);
-      }
-    }
-  }, windowMs);
-  if (interval.unref) interval.unref();
-  return async (ctx, next) => {
-    if (skip(ctx)) return next();
-    const key = keyGenerator(ctx);
-    const now = Date.now();
-    let record = hits.get(key);
-    if (!record || record.resetTime <= now) {
-      record = {
-        hits: 0,
-        resetTime: now + windowMs
-      };
-      hits.set(key, record);
-    }
-    record.hits++;
-    const remaining = Math.max(0, max - record.hits);
-    const resetTime = Math.ceil(record.resetTime / 1e3);
-    if (record.hits > max) {
-      if (headers) {
-        const res = typeof message === "object" ? ctx.json(message, statusCode) : ctx.text(String(message), statusCode);
-        res.headers.set("X-RateLimit-Limit", String(max));
-        res.headers.set("X-RateLimit-Remaining", "0");
-        res.headers.set("X-RateLimit-Reset", String(resetTime));
-        return res;
-      }
-      return typeof message === "object" ? ctx.json(message, statusCode) : ctx.text(String(message), statusCode);
-    }
-    const response = await next();
-    if (response instanceof Response && headers) {
-      response.headers.set("X-RateLimit-Limit", String(max));
-      response.headers.set("X-RateLimit-Remaining", String(remaining));
-      response.headers.set("X-RateLimit-Reset", String(resetTime));
-    }
-    return response;
-  };
-}
-const eta = new eta$2.Eta();
-class ScalarPlugin extends ShokupanRouter {
-  constructor(pluginOptions) {
-    super();
-    this.pluginOptions = pluginOptions;
-    this.init();
+class ValidationError extends Error {
+  constructor(errors) {
+    super("Validation Error");
+    this.errors = errors;
   }
-  init() {
-    this.get("/", (ctx) => {
-      let path2 = ctx.url.toString();
-      if (!path2.endsWith("/")) path2 += "/";
-      return ctx.html(eta.renderString(`<!doctype html>
+  status = 400;
+}
+function isZod(schema) {
+  return typeof schema?.safeParse === "function";
+}
+async function validateZod(schema, data) {
+  const result = await schema.safeParseAsync(data);
+  if (!result.success) {
+    throw new ValidationError(result.error.errors);
+  }
+  return result.data;
+}
+function isTypeBox(schema) {
+  return typeof schema?.Check === "function" && typeof schema?.Errors === "function";
+}
+function validateTypeBox(schema, data) {
+  if (!schema.Check(data)) {
+    throw new ValidationError([...schema.Errors(data)]);
+  }
+  return data;
+}
+function isAjv(schema) {
+  return typeof schema === "function" && "errors" in schema;
+}
+function validateAjv(schema, data) {
+  const valid = schema(data);
+  if (!valid) {
+    throw new ValidationError(schema.errors);
+  }
+  return data;
+}
+const valibot = (schema, parser) => {
+  return {
+    _valibot: true,
+    schema,
+    parser
+  };
+};
+function isValibotWrapper(schema) {
+  return schema?._valibot === true;
+}
+async function validateValibotWrapper(wrapper, data) {
+  const result = await wrapper.parser(wrapper.schema, data);
+  if (!result.success) {
+    throw new ValidationError(result.issues);
+  }
+  return result.output;
+}
+function isClass(schema) {
+  try {
+    if (typeof schema === "function" && /^\s*class\s+/.test(schema.toString())) {
+      return true;
+    }
+    return typeof schema === "function" && schema.prototype && schema.name;
+  } catch {
+    return false;
+  }
+}
+async function validateClassValidator(schema, data) {
+  const object = classTransformer.plainToInstance(schema, data);
+  try {
+    await classValidator.validateOrReject(object);
+    return object;
+  } catch (errors) {
+    const formattedErrors = Array.isArray(errors) ? errors.map((err) => ({
+      property: err.property,
+      constraints: err.constraints,
+      children: err.children
+    })) : errors;
+    throw new ValidationError(formattedErrors);
+  }
+}
+const safelyGetBody = async (ctx) => {
+  const req = ctx.req;
+  if (req._bodyParsed) {
+    return req._bodyValue;
+  }
+  try {
+    let data;
+    if (typeof req.json === "function") {
+      data = await req.json();
+    } else {
+      data = req.body;
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch {
+        }
+      }
+    }
+    req._bodyParsed = true;
+    req._bodyValue = data;
+    Object.defineProperty(req, "json", {
+      value: async () => req._bodyValue,
+      configurable: true
+    });
+    return data;
+  } catch (e) {
+    return {};
+  }
+};
+function validate(config) {
+  return async (ctx, next) => {
+    const dataToValidate = {};
+    if (config.params) dataToValidate.params = ctx.params;
+    let queryObj;
+    if (config.query) {
+      const url = new URL(ctx.req.url);
+      queryObj = Object.fromEntries(url.searchParams.entries());
+      dataToValidate.query = queryObj;
+    }
+    if (config.headers) dataToValidate.headers = Object.fromEntries(ctx.req.headers.entries());
+    let body;
+    if (config.body) {
+      body = await safelyGetBody(ctx);
+      dataToValidate.body = body;
+    }
+    if (ctx.app?.applicationConfig.hooks?.beforeValidate) {
+      await ctx.app.applicationConfig.hooks.beforeValidate(ctx, dataToValidate);
+    }
+    if (config.params) {
+      ctx.params = await runValidation(config.params, ctx.params);
+    }
+    let validQuery;
+    if (config.query && queryObj) {
+      validQuery = await runValidation(config.query, queryObj);
+    }
+    if (config.headers) {
+      const headersObj = Object.fromEntries(ctx.req.headers.entries());
+      await runValidation(config.headers, headersObj);
+    }
+    let validBody;
+    if (config.body) {
+      const b = body ?? await safelyGetBody(ctx);
+      validBody = await runValidation(config.body, b);
+      const req = ctx.req;
+      req._bodyValue = validBody;
+      Object.defineProperty(req, "json", {
+        value: async () => validBody,
+        configurable: true
+      });
+      ctx.body = validBody;
+    }
+    if (ctx.app?.applicationConfig.hooks?.afterValidate) {
+      const validatedData = { ...dataToValidate };
+      if (config.params) validatedData.params = ctx.params;
+      if (config.query) validatedData.query = validQuery;
+      if (config.body) validatedData.body = validBody;
+      await ctx.app.applicationConfig.hooks.afterValidate(ctx, validatedData);
+    }
+    return next();
+  };
+}
+async function runValidation(schema, data) {
+  if (isZod(schema)) {
+    return validateZod(schema, data);
+  }
+  if (isTypeBox(schema)) {
+    return validateTypeBox(schema, data);
+  }
+  if (isAjv(schema)) {
+    return validateAjv(schema, data);
+  }
+  if (isValibotWrapper(schema)) {
+    return validateValibotWrapper(schema, data);
+  }
+  if (isClass(schema)) {
+    return validateClassValidator(schema, data);
+  }
+  if (isTypeBox(schema)) {
+    return validateTypeBox(schema, data);
+  }
+  if (isAjv(schema)) {
+    return validateAjv(schema, data);
+  }
+  if (isValibotWrapper(schema)) {
+    return validateValibotWrapper(schema, data);
+  }
+  if (typeof schema === "function") {
+    return schema(data);
+  }
+  throw new Error("Unknown validator type provided. Please use a supported library (Zod, Ajv, TypeBox) or a custom function.");
+}
+const ajv = new Ajv({ coerceTypes: true, allErrors: true });
+addFormats(ajv);
+const compiledValidators = /* @__PURE__ */ new WeakMap();
+function openApiValidator() {
+  return async (ctx, next) => {
+    const app = ctx.app;
+    if (!app || !app.openApiSpec) {
+      return next();
+    }
+    let cache = compiledValidators.get(app);
+    if (!cache) {
+      cache = compileValidators(app.openApiSpec);
+      compiledValidators.set(app, cache);
+    }
+    const method = ctx.req.method.toLowerCase();
+    let matchPath;
+    if (cache.has(ctx.path)) {
+      matchPath = ctx.path;
+    } else {
+      for (const specPath of cache.keys()) {
+        const regexStr = "^" + specPath.replace(/{([^}]+)}/g, "([^/]+)") + "$";
+        const regex = new RegExp(regexStr);
+        const match = regex.exec(ctx.path);
+        if (match) {
+          matchPath = specPath;
+          break;
+        }
+      }
+    }
+    if (!matchPath) {
+      return next();
+    }
+    const validators = cache.get(matchPath)?.[method];
+    if (!validators) {
+      return next();
+    }
+    const errors = [];
+    if (validators.body) {
+      let body;
+      try {
+        body = await ctx.req.json().catch(() => ({}));
+      } catch {
+        body = {};
+      }
+      const valid = validators.body(body);
+      if (!valid && validators.body.errors) {
+        errors.push(...validators.body.errors.map((e) => ({ ...e, location: "body" })));
+      }
+    }
+    if (validators.query) {
+      const query = Object.fromEntries(new URL(ctx.req.url).searchParams.entries());
+      const valid = validators.query(query);
+      if (!valid && validators.query.errors) {
+        errors.push(...validators.query.errors.map((e) => ({ ...e, location: "query" })));
+      }
+    }
+    if (validators.params) {
+      let params = ctx.params;
+      if (Object.keys(params).length === 0 && matchPath) {
+        const paramNames = (matchPath.match(/{([^}]+)}/g) || []).map((s) => s.slice(1, -1));
+        if (paramNames.length > 0) {
+          const regexStr = "^" + matchPath.replace(/{([^}]+)}/g, "([^/]+)") + "$";
+          const regex = new RegExp(regexStr);
+          const match = regex.exec(ctx.path);
+          if (match) {
+            params = {};
+            paramNames.forEach((name, i) => {
+              params[name] = match[i + 1];
+            });
+          }
+        }
+      }
+      const valid = validators.params(params);
+      if (!valid && validators.params.errors) {
+        errors.push(...validators.params.errors.map((e) => ({ ...e, location: "path" })));
+      }
+    }
+    if (validators.headers) {
+      const headers = Object.fromEntries(ctx.req.headers.entries());
+      const valid = validators.headers(headers);
+      if (!valid && validators.headers.errors) {
+        errors.push(...validators.headers.errors.map((e) => ({ ...e, location: "header" })));
+      }
+    }
+    if (errors.length > 0) {
+      throw new ValidationError(errors);
+    }
+    return next();
+  };
+}
+function compileValidators(spec) {
+  const cache = /* @__PURE__ */ new Map();
+  for (const [path2, pathItem] of Object.entries(spec.paths || {})) {
+    const pathValidators = {};
+    for (const [method, operation] of Object.entries(pathItem)) {
+      if (method === "parameters" || method === "summary" || method === "description") continue;
+      const oper = operation;
+      const validators = {};
+      if (oper.requestBody?.content?.["application/json"]?.schema) {
+        validators.body = ajv.compile(oper.requestBody.content["application/json"].schema);
+      }
+      const parameters = [...oper.parameters || [], ...pathItem.parameters || []];
+      const queryProps = {};
+      const pathProps = {};
+      const headerProps = {};
+      const queryRequired = [];
+      const pathRequired = [];
+      const headerRequired = [];
+      for (const param of parameters) {
+        if (param.in === "query") {
+          queryProps[param.name] = param.schema || {};
+          if (param.required) queryRequired.push(param.name);
+        } else if (param.in === "path") {
+          pathProps[param.name] = param.schema || {};
+          pathRequired.push(param.name);
+        } else if (param.in === "header") {
+          headerProps[param.name] = param.schema || {};
+          if (param.required) headerRequired.push(param.name);
+        }
+      }
+      if (Object.keys(queryProps).length > 0) {
+        validators.query = ajv.compile({
+          type: "object",
+          properties: queryProps,
+          required: queryRequired.length > 0 ? queryRequired : void 0
+        });
+      }
+      if (Object.keys(pathProps).length > 0) {
+        validators.params = ajv.compile({
+          type: "object",
+          properties: pathProps,
+          required: pathRequired.length > 0 ? pathRequired : void 0
+        });
+      }
+      if (Object.keys(headerProps).length > 0) {
+        validators.headers = ajv.compile({
+          type: "object",
+          properties: headerProps,
+          required: headerRequired.length > 0 ? headerRequired : void 0
+        });
+      }
+      pathValidators[method] = validators;
+    }
+    cache.set(path2, pathValidators);
+  }
+  return cache;
+}
+function RateLimit(options = {}) {
+  const windowMs = options.windowMs || 60 * 1e3;
+  const max = options.max || 5;
+  const message = options.message || "Too many requests, please try again later.";
+  const statusCode = options.statusCode || 429;
+  const headers = options.headers !== false;
+  const keyGenerator = options.keyGenerator || ((ctx) => {
+    return ctx.headers.get("x-forwarded-for") || ctx.url.hostname || "unknown";
+  });
+  const skip = options.skip || (() => false);
+  const hits = /* @__PURE__ */ new Map();
+  const interval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, record] of hits.entries()) {
+      if (record.resetTime <= now) {
+        hits.delete(key);
+      }
+    }
+  }, windowMs);
+  interval.unref?.();
+  return async (ctx, next) => {
+    if (skip(ctx)) return next();
+    const key = keyGenerator(ctx);
+    const now = Date.now();
+    let record = hits.get(key);
+    if (!record || record.resetTime <= now) {
+      record = {
+        hits: 0,
+        resetTime: now + windowMs
+      };
+      hits.set(key, record);
+    }
+    record.hits++;
+    const remaining = Math.max(0, max - record.hits);
+    const resetTime = Math.ceil(record.resetTime / 1e3);
+    if (record.hits > max) {
+      if (headers) {
+        const res = typeof message === "object" ? ctx.json(message, statusCode) : ctx.text(String(message), statusCode);
+        res.headers.set("X-RateLimit-Limit", String(max));
+        res.headers.set("X-RateLimit-Remaining", "0");
+        res.headers.set("X-RateLimit-Reset", String(resetTime));
+        return res;
+      }
+      return typeof message === "object" ? ctx.json(message, statusCode) : ctx.text(String(message), statusCode);
+    }
+    const response = await next();
+    if (response instanceof Response && headers) {
+      response.headers.set("X-RateLimit-Limit", String(max));
+      response.headers.set("X-RateLimit-Remaining", String(remaining));
+      response.headers.set("X-RateLimit-Reset", String(resetTime));
+    }
+    return response;
+  };
+}
+const eta = new eta$2.Eta();
+class ScalarPlugin extends ShokupanRouter {
+  constructor(pluginOptions) {
+    super();
+    this.pluginOptions = pluginOptions;
+    this.init();
+  }
+  init() {
+    this.get("/", (ctx) => {
+      let path2 = ctx.url.toString();
+      if (!path2.endsWith("/")) path2 += "/";
+      return ctx.html(eta.renderString(`<!doctype html>
                 <html>
                 <head>
                     <title>API Reference</title>
@@ -2752,194 +3306,6 @@ function Session(options) {
     return result;
   };
 }
-class ValidationError extends Error {
-  constructor(errors) {
-    super("Validation Error");
-    this.errors = errors;
-  }
-  status = 400;
-}
-function isZod(schema) {
-  return typeof schema?.safeParse === "function";
-}
-async function validateZod(schema, data) {
-  const result = await schema.safeParseAsync(data);
-  if (!result.success) {
-    throw new ValidationError(result.error.errors);
-  }
-  return result.data;
-}
-function isTypeBox(schema) {
-  return typeof schema?.Check === "function" && typeof schema?.Errors === "function";
-}
-function validateTypeBox(schema, data) {
-  if (!schema.Check(data)) {
-    throw new ValidationError([...schema.Errors(data)]);
-  }
-  return data;
-}
-function isAjv(schema) {
-  return typeof schema === "function" && "errors" in schema;
-}
-function validateAjv(schema, data) {
-  const valid = schema(data);
-  if (!valid) {
-    throw new ValidationError(schema.errors);
-  }
-  return data;
-}
-const valibot = (schema, parser) => {
-  return {
-    _valibot: true,
-    schema,
-    parser
-  };
-};
-function isValibotWrapper(schema) {
-  return schema?._valibot === true;
-}
-async function validateValibotWrapper(wrapper, data) {
-  const result = await wrapper.parser(wrapper.schema, data);
-  if (!result.success) {
-    throw new ValidationError(result.issues);
-  }
-  return result.output;
-}
-function isClass(schema) {
-  try {
-    if (typeof schema === "function" && /^\s*class\s+/.test(schema.toString())) {
-      return true;
-    }
-    return typeof schema === "function" && schema.prototype && schema.name;
-  } catch {
-    return false;
-  }
-}
-async function validateClassValidator(schema, data) {
-  const object = classTransformer.plainToInstance(schema, data);
-  try {
-    await classValidator.validateOrReject(object);
-    return object;
-  } catch (errors) {
-    const formattedErrors = Array.isArray(errors) ? errors.map((err) => ({
-      property: err.property,
-      constraints: err.constraints,
-      children: err.children
-    })) : errors;
-    throw new ValidationError(formattedErrors);
-  }
-}
-const safelyGetBody = async (ctx) => {
-  const req = ctx.req;
-  if (req._bodyParsed) {
-    return req._bodyValue;
-  }
-  try {
-    let data;
-    if (typeof req.json === "function") {
-      data = await req.json();
-    } else {
-      data = req.body;
-      if (typeof data === "string") {
-        try {
-          data = JSON.parse(data);
-        } catch {
-        }
-      }
-    }
-    req._bodyParsed = true;
-    req._bodyValue = data;
-    Object.defineProperty(req, "json", {
-      value: async () => req._bodyValue,
-      configurable: true
-    });
-    return data;
-  } catch (e) {
-    return {};
-  }
-};
-function validate(config) {
-  return async (ctx, next) => {
-    const dataToValidate = {};
-    if (config.params) dataToValidate.params = ctx.params;
-    let queryObj;
-    if (config.query) {
-      const url = new URL(ctx.req.url);
-      queryObj = Object.fromEntries(url.searchParams.entries());
-      dataToValidate.query = queryObj;
-    }
-    if (config.headers) dataToValidate.headers = Object.fromEntries(ctx.req.headers.entries());
-    let body;
-    if (config.body) {
-      body = await safelyGetBody(ctx);
-      dataToValidate.body = body;
-    }
-    if (ctx.app?.applicationConfig.hooks?.beforeValidate) {
-      await ctx.app.applicationConfig.hooks.beforeValidate(ctx, dataToValidate);
-    }
-    if (config.params) {
-      ctx.params = await runValidation(config.params, ctx.params);
-    }
-    let validQuery;
-    if (config.query && queryObj) {
-      validQuery = await runValidation(config.query, queryObj);
-    }
-    if (config.headers) {
-      const headersObj = Object.fromEntries(ctx.req.headers.entries());
-      await runValidation(config.headers, headersObj);
-    }
-    let validBody;
-    if (config.body) {
-      const b = body ?? await safelyGetBody(ctx);
-      validBody = await runValidation(config.body, b);
-      const req = ctx.req;
-      req._bodyValue = validBody;
-      Object.defineProperty(req, "json", {
-        value: async () => validBody,
-        configurable: true
-      });
-      ctx.body = validBody;
-    }
-    if (ctx.app?.applicationConfig.hooks?.afterValidate) {
-      const validatedData = { ...dataToValidate };
-      if (config.params) validatedData.params = ctx.params;
-      if (config.query) validatedData.query = validQuery;
-      if (config.body) validatedData.body = validBody;
-      await ctx.app.applicationConfig.hooks.afterValidate(ctx, validatedData);
-    }
-    return next();
-  };
-}
-async function runValidation(schema, data) {
-  if (isZod(schema)) {
-    return validateZod(schema, data);
-  }
-  if (isTypeBox(schema)) {
-    return validateTypeBox(schema, data);
-  }
-  if (isAjv(schema)) {
-    return validateAjv(schema, data);
-  }
-  if (isValibotWrapper(schema)) {
-    return validateValibotWrapper(schema, data);
-  }
-  if (isClass(schema)) {
-    return validateClassValidator(schema, data);
-  }
-  if (isTypeBox(schema)) {
-    return validateTypeBox(schema, data);
-  }
-  if (isAjv(schema)) {
-    return validateAjv(schema, data);
-  }
-  if (isValibotWrapper(schema)) {
-    return validateValibotWrapper(schema, data);
-  }
-  if (typeof schema === "function") {
-    return schema(data);
-  }
-  throw new Error("Unknown validator type provided. Please use a supported library (Zod, Ajv, TypeBox) or a custom function.");
-}
 exports.$appRoot = $appRoot;
 exports.$childControllers = $childControllers;
 exports.$childRouters = $childRouters;
@@ -2994,6 +3360,7 @@ exports.Spec = Spec;
 exports.Use = Use;
 exports.ValidationError = ValidationError;
 exports.compose = compose;
+exports.openApiValidator = openApiValidator;
 exports.useExpress = useExpress;
 exports.valibot = valibot;
 exports.validate = validate;