hono 4.9.12 → 4.10.1

package/dist/cjs/helper/proxy/index.js

@@ -21,20 +21,38 @@ __export(proxy_exports, {
   proxy: () => proxy
 });
 module.exports = __toCommonJS(proxy_exports);
+var import_http_exception = require("../../http-exception");
 const hopByHopHeaders = [
   "connection",
   "keep-alive",
   "proxy-authenticate",
   "proxy-authorization",
   "te",
-  "trailers",
-  "transfer-encoding"
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
 ];
-const buildRequestInitFromRequest = (request) => {
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
   if (!request) {
     return {};
   }
   const headers = new Headers(request.headers);
+  if (strictConnectionProcessing) {
+    const connectionValue = headers.get("connection");
+    if (connectionValue) {
+      const headerNames = connectionValue.split(",").map((h) => h.trim());
+      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+      if (invalidHeaders.length > 0) {
+        throw new import_http_exception.HTTPException(400, {
+          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
+        });
+      }
+      headerNames.forEach((headerName) => {
+        headers.delete(headerName);
+      });
+    }
+  }
   hopByHopHeaders.forEach((header) => {
     headers.delete(header);
   });
@@ -62,9 +80,14 @@ const preprocessRequestInit = (requestInit) => {
   return requestInit;
 };
 const proxy = async (input, proxyInit) => {
-  const { raw, customFetch, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+  const {
+    raw,
+    customFetch,
+    strictConnectionProcessing = false,
+    ...requestInit
+  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
   const req = new Request(input, {
-    ...buildRequestInitFromRequest(raw),
+    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
     ...preprocessRequestInit(requestInit)
   });
   req.headers.delete("accept-encoding");

package/dist/cjs/helper/ssg/ssg.js

@@ -23,6 +23,7 @@ __export(ssg_exports, {
   combineAfterResponseHooks: () => combineAfterResponseHooks,
   combineBeforeRequestHooks: () => combineBeforeRequestHooks,
   defaultExtensionMap: () => defaultExtensionMap,
+  defaultPlugin: () => defaultPlugin,
   fetchRoutesContent: () => fetchRoutesContent,
   saveContentToFile: () => saveContentToFile,
   toSSG: () => toSSG
@@ -213,11 +214,19 @@ const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   }
   return filePath;
 };
+const defaultPlugin = {
+  afterResponseHook: (res) => {
+    if (res.status !== 200) {
+      return false;
+    }
+    return res;
+  }
+};
 const toSSG = async (app, fs, options) => {
   let result;
   const getInfoPromises = [];
   const savePromises = [];
-  const plugins = options?.plugins || [];
+  const plugins = options?.plugins || [defaultPlugin];
   const beforeRequestHooks = [];
   const afterResponseHooks = [];
   const afterGenerateHooks = [];
@@ -310,6 +319,7 @@ const toSSG = async (app, fs, options) => {
   combineAfterResponseHooks,
   combineBeforeRequestHooks,
   defaultExtensionMap,
+  defaultPlugin,
   fetchRoutesContent,
   saveContentToFile,
   toSSG

package/dist/cjs/request.js

@@ -18,9 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var request_exports = {};
 __export(request_exports, {
-  HonoRequest: () => HonoRequest
+  HonoRequest: () => HonoRequest,
+  cloneRawRequest: () => cloneRawRequest
 });
 module.exports = __toCommonJS(request_exports);
+var import_http_exception = require("./http-exception");
 var import_constants = require("./request/constants");
 var import_body = require("./utils/body");
 var import_url = require("./utils/url");
@@ -133,7 +135,34 @@ class HonoRequest {
     return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
   }
 }
+const cloneRawRequest = async (req) => {
+  if (!req.raw.bodyUsed) {
+    return req.raw.clone();
+  }
+  const cacheKey = Object.keys(req.bodyCache)[0];
+  if (!cacheKey) {
+    throw new import_http_exception.HTTPException(500, {
+      message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly."
+    });
+  }
+  const requestInit = {
+    body: await req[cacheKey](),
+    cache: req.raw.cache,
+    credentials: req.raw.credentials,
+    headers: req.header(),
+    integrity: req.raw.integrity,
+    keepalive: req.raw.keepalive,
+    method: req.method,
+    mode: req.raw.mode,
+    redirect: req.raw.redirect,
+    referrer: req.raw.referrer,
+    referrerPolicy: req.raw.referrerPolicy,
+    signal: req.raw.signal
+  };
+  return new Request(req.url, requestInit);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  HonoRequest
+  HonoRequest,
+  cloneRawRequest
 });

package/dist/cjs/validator/validator.js

@@ -100,7 +100,7 @@ const validator = (target, validationFunc) => {
       return res;
     }
     c.req.addValidatedData(target, res);
-    await next();
+    return await next();
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/helper/proxy/index.js

@@ -1,18 +1,36 @@
 // src/helper/proxy/index.ts
+import { HTTPException } from "../../http-exception.js";
 var hopByHopHeaders = [
   "connection",
   "keep-alive",
   "proxy-authenticate",
   "proxy-authorization",
   "te",
-  "trailers",
-  "transfer-encoding"
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
 ];
-var buildRequestInitFromRequest = (request) => {
+var ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+var buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
   if (!request) {
     return {};
   }
   const headers = new Headers(request.headers);
+  if (strictConnectionProcessing) {
+    const connectionValue = headers.get("connection");
+    if (connectionValue) {
+      const headerNames = connectionValue.split(",").map((h) => h.trim());
+      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+      if (invalidHeaders.length > 0) {
+        throw new HTTPException(400, {
+          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
+        });
+      }
+      headerNames.forEach((headerName) => {
+        headers.delete(headerName);
+      });
+    }
+  }
   hopByHopHeaders.forEach((header) => {
     headers.delete(header);
   });
@@ -40,9 +58,14 @@ var preprocessRequestInit = (requestInit) => {
   return requestInit;
 };
 var proxy = async (input, proxyInit) => {
-  const { raw, customFetch, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+  const {
+    raw,
+    customFetch,
+    strictConnectionProcessing = false,
+    ...requestInit
+  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
   const req = new Request(input, {
-    ...buildRequestInitFromRequest(raw),
+    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
     ...preprocessRequestInit(requestInit)
   });
   req.headers.delete("accept-encoding");

package/dist/helper/ssg/ssg.js

@@ -184,11 +184,19 @@ var saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   }
   return filePath;
 };
+var defaultPlugin = {
+  afterResponseHook: (res) => {
+    if (res.status !== 200) {
+      return false;
+    }
+    return res;
+  }
+};
 var toSSG = async (app, fs, options) => {
   let result;
   const getInfoPromises = [];
   const savePromises = [];
-  const plugins = options?.plugins || [];
+  const plugins = options?.plugins || [defaultPlugin];
   const beforeRequestHooks = [];
   const afterResponseHooks = [];
   const afterGenerateHooks = [];
@@ -280,6 +288,7 @@ export {
   combineAfterResponseHooks,
   combineBeforeRequestHooks,
   defaultExtensionMap,
+  defaultPlugin,
   fetchRoutesContent,
   saveContentToFile,
   toSSG

package/dist/request.js

@@ -1,4 +1,5 @@
 // src/request.ts
+import { HTTPException } from "./http-exception.js";
 import { GET_MATCH_RESULT } from "./request/constants.js";
 import { parseBody } from "./utils/body.js";
 import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from "./utils/url.js";
@@ -111,6 +112,33 @@ var HonoRequest = class {
     return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
   }
 };
+var cloneRawRequest = async (req) => {
+  if (!req.raw.bodyUsed) {
+    return req.raw.clone();
+  }
+  const cacheKey = Object.keys(req.bodyCache)[0];
+  if (!cacheKey) {
+    throw new HTTPException(500, {
+      message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly."
+    });
+  }
+  const requestInit = {
+    body: await req[cacheKey](),
+    cache: req.raw.cache,
+    credentials: req.raw.credentials,
+    headers: req.header(),
+    integrity: req.raw.integrity,
+    keepalive: req.raw.keepalive,
+    method: req.method,
+    mode: req.raw.mode,
+    redirect: req.raw.redirect,
+    referrer: req.raw.referrer,
+    referrerPolicy: req.raw.referrerPolicy,
+    signal: req.raw.signal
+  };
+  return new Request(req.url, requestInit);
+};
 export {
-  HonoRequest
+  HonoRequest,
+  cloneRawRequest
 };

package/dist/types/helper/factory/index.d.ts

@@ -344,12 +344,12 @@ export declare class Factory<E extends Env = Env, P extends string = string> {
         defaultAppOptions?: HonoOptions<E>;
     });
     createApp: (options?: HonoOptions<E>) => Hono<E>;
-    createMiddleware: <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
+    createMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
     createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
     initApp?: InitApp<E>;
     defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
-export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
+export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
 export {};

package/dist/types/helper/proxy/index.d.ts

@@ -10,6 +10,18 @@ interface ProxyRequestInit extends Omit<RequestInit, "headers"> {
         string
     ][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
     customFetch?: (request: Request) => Promise<Response>;
+    /**
+     * Enable strict RFC 9110 compliance for Connection header processing.
+     *
+     * - `false` (default): Ignores Connection header to prevent potential
+     *   Hop-by-Hop Header Injection attacks. Recommended for untrusted clients.
+     * - `true`: Processes Connection header per RFC 9110 and removes listed headers.
+     *   Only use in trusted environments.
+     *
+     * @default false
+     * @see https://datatracker.ietf.org/doc/html/rfc9110#section-7.6.1
+     */
+    strictConnectionProcessing?: boolean;
 }
 interface ProxyFetch {
     (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
@@ -49,6 +61,14 @@ interface ProxyFetch {
  *     },
  *   })
  * })
+ *
+ * // Strict RFC compliance mode (use only in trusted environments)
+ * app.get('/internal-proxy/:path', (c) => {
+ *   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+ *     ...c.req,
+ *     strictConnectionProcessing: true,
+ *   })
+ * })
  * ```
  */
 export declare const proxy: ProxyFetch;

package/dist/types/helper/ssg/ssg.d.ts

@@ -83,6 +83,14 @@ export interface ToSSGInterface {
 export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = "/"> {
     (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
 }
+/**
+ * The default plugin that defines the recommended behavior.
+ *
+ * @experimental
+ * `defaultPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const defaultPlugin: SSGPlugin;
 /**
  * @experimental
  * `toSSG` is an experimental feature.

package/dist/types/request.d.ts

@@ -283,4 +283,36 @@ export declare class HonoRequest<P extends string = "/", I extends Input["out"]
      */
     get routePath(): string;
 }
+/**
+ * Clones a HonoRequest's underlying raw Request object.
+ *
+ * This utility handles both consumed and unconsumed request bodies:
+ * - If the request body hasn't been consumed, it uses the native `clone()` method
+ * - If the request body has been consumed, it reconstructs a new Request using cached body data
+ *
+ * This is particularly useful when you need to:
+ * - Process the same request body multiple times
+ * - Pass requests to external services after validation
+ *
+ * @param req - The HonoRequest object to clone
+ * @returns A Promise that resolves to a new Request object with the same properties
+ * @throws {HTTPException} If the request body was consumed directly via `req.raw`
+ *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
+ *   impossible to reconstruct the body from cache
+ *
+ * @example
+ * ```ts
+ * // Clone after consuming the body (e.g., after validation)
+ * app.post('/forward',
+ *   validator('json', (data) => data),
+ *   async (c) => {
+ *     const validated = c.req.valid('json')
+ *     // Body has been consumed, but cloneRawRequest still works
+ *     const clonedReq = await cloneRawRequest(c.req)
+ *     return fetch('http://backend-service.com', clonedReq)
+ *   }
+ * )
+ * ```
+ */
+export declare const cloneRawRequest: (req: HonoRequest) => Promise<Request>;
 export {};

package/dist/types/types.d.ts

@@ -31,8 +31,8 @@ export interface RouterRoute {
 }
 export type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
 export type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
-export type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
-export type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
+export type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> = Response> = (c: Context<E, P, I>, next: Next) => Promise<R | void>;
+export type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I, R>;
 export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export interface HTTPResponseError extends Error {
     getResponse: () => Response;
@@ -46,14 +46,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
-    ]>>(...handlers: [
-        H<E2, P, I>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
         H<E3, P, I2, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
         E2,
         E3
-    ]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
@@ -62,23 +62,23 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E,
         E2,
         E3
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
         H<E4, P, I3, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
         E2,
         E3,
         E4
-    ]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
         H<E3, MergedPath, I2, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -91,10 +91,10 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E2,
         E3,
         E4
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
         H<E5, P, I4, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -102,7 +102,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E3,
         E4,
         E5
-    ]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -110,11 +110,11 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E,
         E2,
         E3
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
         H<E4, MergedPath, I3, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -133,11 +133,11 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E3,
         E4,
         E5
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
         H<E6, P, I5, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -146,7 +146,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E4,
         E5,
         E6
-    ]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -159,12 +159,12 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E2,
         E3,
         E4
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
         H<E5, MergedPath, I4, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -190,12 +190,12 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E4,
         E5,
         E6
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
-        H<E6, P, I5>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
+        H<E6, P, I5> & M5,
         H<E7, P, I6, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -205,7 +205,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E5,
         E6,
         E7
-    ]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -224,13 +224,13 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E3,
         E4,
         E5
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
         H<E6, MergedPath, I5, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -264,13 +264,13 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E5,
         E6,
         E7
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
-        H<E6, P, I5>,
-        H<E7, P, I6>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
+        H<E6, P, I5> & M5,
+        H<E7, P, I6> & M6,
         H<E8, P, I7, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -281,7 +281,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E6,
         E7,
         E8
-    ]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -307,14 +307,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E4,
         E5,
         E6
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
+        H<E6, MergedPath, I5> & M5,
         H<E7, MergedPath, I6, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -357,14 +357,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E6,
         E7,
         E8
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
-        H<E6, P, I5>,
-        H<E7, P, I6>,
-        H<E8, P, I7>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
+        H<E6, P, I5> & M5,
+        H<E7, P, I6> & M6,
+        H<E8, P, I7> & M7,
         H<E9, P, I8, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -376,7 +376,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E7,
         E8,
         E9
-    ]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -410,15 +410,15 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E5,
         E6,
         E7
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
+        H<E6, MergedPath, I5> & M5,
+        H<E7, MergedPath, I6> & M6,
         H<E8, MergedPath, I7, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -471,15 +471,15 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E7,
         E8,
         E9
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
-        H<E6, P, I5>,
-        H<E7, P, I6>,
-        H<E8, P, I7>,
-        H<E9, P, I8>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
+        H<E6, P, I5> & M5,
+        H<E7, P, I6> & M6,
+        H<E8, P, I7> & M7,
+        H<E9, P, I8> & M8,
         H<E10, P, I9, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -492,7 +492,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E8,
         E9,
         E10
-    ]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -535,16 +535,16 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E6,
         E7,
         E8
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
+        H<E6, MergedPath, I5> & M5,
+        H<E7, MergedPath, I6> & M6,
+        H<E8, MergedPath, I7> & M7,
         H<E9, MergedPath, I8, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -608,16 +608,16 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E8,
         E9,
         E10
-    ]>>(...handlers: [
-        H<E2, P, I>,
-        H<E3, P, I2>,
-        H<E4, P, I3>,
-        H<E5, P, I4>,
-        H<E6, P, I5>,
-        H<E7, P, I6>,
-        H<E8, P, I7>,
-        H<E9, P, I8>,
-        H<E10, P, I9>,
+    ]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>, M9 extends H<E10, P, any> = H<E10, P, any>>(...handlers: [
+        H<E2, P, I> & M1,
+        H<E3, P, I2> & M2,
+        H<E4, P, I3> & M3,
+        H<E5, P, I4> & M4,
+        H<E6, P, I5> & M5,
+        H<E7, P, I6> & M6,
+        H<E8, P, I7> & M7,
+        H<E9, P, I8> & M8,
+        H<E10, P, I9> & M9,
         H<E11, P, I10, R>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
@@ -631,7 +631,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E9,
         E10,
         E11
-    ]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
+    ]>, S & ToSchema<M, P, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -684,17 +684,17 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E7,
         E8,
         E9
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
+        H<E6, MergedPath, I5> & M5,
+        H<E7, MergedPath, I6> & M6,
+        H<E8, MergedPath, I7> & M7,
+        H<E9, MergedPath, I8> & M8,
         H<E10, MergedPath, I9, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
         E,
         E2
@@ -758,18 +758,18 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         E8,
         E9,
         E10
-    ]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9>,
+    ]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>, M9 extends H<E10, MergedPath, any> = H<E10, MergedPath, any>>(path: P, ...handlers: [
+        H<E2, MergedPath, I> & M1,
+        H<E3, MergedPath, I2> & M2,
+        H<E4, MergedPath, I3> & M3,
+        H<E5, MergedPath, I4> & M4,
+        H<E6, MergedPath, I5> & M5,
+        H<E7, MergedPath, I6> & M6,
+        H<E8, MergedPath, I7> & M7,
+        H<E9, MergedPath, I8> & M8,
+        H<E10, MergedPath, I9> & M9,
         H<E11, MergedPath, I10, R>
-    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
+    ]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath>;
     <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): HonoBase<E, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): HonoBase<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
@@ -794,7 +794,7 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         E2,
         E3
     ]>, S, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath>): HonoBase<IntersectNonAnyTypes<[
+    <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath, any, any>): HonoBase<IntersectNonAnyTypes<[
         E,
         E2
     ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
@@ -806,9 +806,9 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         E2,
         E3
     ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
-        MiddlewareHandler<E2, P>,
-        MiddlewareHandler<E3, P>,
-        MiddlewareHandler<E4, P>
+        MiddlewareHandler<E2, P, any, any>,
+        MiddlewareHandler<E3, P, any, any>,
+        MiddlewareHandler<E4, P, any, any>
     ]): HonoBase<IntersectNonAnyTypes<[
         E,
         E2,
@@ -2399,6 +2399,8 @@ export type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F exte
     _format: F;
 };
 type MergeTypedResponse<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
+type MergeTypedResponseStrict<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : never : T extends TypedResponse ? T : never;
+type MergeMiddlewareResponse<T> = MergeTypedResponseStrict<ExtractHandlerResponse<T>>;
 export type FormValue = string | Blob;
 export type ParsedFormValue = string | File;
 export type ValidationTargets<T extends FormValue = ParsedFormValue, P extends string = string> = {
@@ -2419,6 +2421,14 @@ export type InputToDataByTarget<T extends Input["out"], Target extends keyof Val
 } ? R : never;
 export type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
 export type ExtractSchema<T> = UnionToIntersection<T extends HonoBase<infer _, infer S, any> ? S : never>;
+export type ExtractSchemaForStatusCode<T, Status extends number> = {
+    [Path in keyof ExtractSchema<T>]: {
+        [Method in keyof ExtractSchema<T>[Path]]: Extract<ExtractSchema<T>[Path][Method], {
+            status: Status;
+        }>;
+    };
+};
+export type ExtractHandlerResponse<T> = T extends (c: any, next: any) => Promise<infer R> ? Exclude<R, void> extends never ? never : Exclude<R, void> extends Response | TypedResponse<any, any, any> ? Exclude<R, void> : never : T extends (c: any, next: any) => infer R ? R extends Response | TypedResponse<any, any, any> ? R : never : never;
 type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends T ? {} : T) : T>;
 export type IntersectNonAnyTypes<T extends any[]> = T extends [
     infer Head,

package/dist/types/validator/validator.d.ts

@@ -2,25 +2,26 @@ import type { Context } from '../context';
 import type { Env, MiddlewareHandler, TypedResponse, ValidationTargets } from '../types';
 type ValidationTargetKeysWithBody = "form" | "json";
 type ValidationTargetByMethod<M> = M extends "get" | "head" ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody> : keyof ValidationTargets;
-export type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | Response | Promise<OutputType> | Promise<Response>;
-type ExcludeResponseType<T> = T extends Response & TypedResponse<any> ? never : T;
-export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, OutputType = ValidationTargets[U], OutputTypeExcludeResponseType = ExcludeResponseType<OutputType>, P2 extends string = P, V extends {
+export type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | TypedResponse | Promise<OutputType> | Promise<TypedResponse>;
+export type ExtractValidationResponse<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : PR extends Response ? PR : PR extends undefined ? never : never : R extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : R extends Response ? R : R extends undefined ? never : never : never;
+export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, P2 extends string = P, VF extends (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any = (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any, V extends {
     in: {
-        [K in U]: K extends "json" ? unknown extends InputType ? OutputTypeExcludeResponseType : InputType : {
-            [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2];
+        [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : {
+            [K2 in keyof ExtractValidatorOutput<VF>]: ValidationTargets[K][K2];
         };
     };
     out: {
-        [K in U]: OutputTypeExcludeResponseType;
+        [K in U]: ExtractValidatorOutput<VF>;
     };
 } = {
     in: {
-        [K in U]: K extends "json" ? unknown extends InputType ? OutputTypeExcludeResponseType : InputType : {
-            [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2];
+        [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : {
+            [K2 in keyof ExtractValidatorOutput<VF>]: ValidationTargets[K][K2];
         };
     };
     out: {
-        [K in U]: OutputTypeExcludeResponseType;
+        [K in U]: ExtractValidatorOutput<VF>;
     };
-}, E extends Env = any>(target: U, validationFunc: ValidationFunction<unknown extends InputType ? ValidationTargets[U] : InputType, OutputType, E, P2>) => MiddlewareHandler<E, P, V>;
+}, E extends Env = any>(target: U, validationFunc: VF) => MiddlewareHandler<E, P, V, ExtractValidationResponse<VF>>;
+export type ExtractValidatorOutput<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends Response | TypedResponse<any, any, any> ? never : PR : R extends Response | TypedResponse<any, any, any> ? never : R : never;
 export {};

package/dist/validator/validator.js

@@ -78,7 +78,7 @@ var validator = (target, validationFunc) => {
       return res;
     }
     c.req.addValidatedData(target, res);
-    await next();
+    return await next();
   };
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.9.12",
+  "version": "4.10.1",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",