hono 4.1.2 → 4.1.4

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

@@ -74,15 +74,16 @@ const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook,
   for (const route of (0, import_utils2.filterStaticGenerateRoutes)(app)) {
     const thisRouteBaseURL = new URL(route.path, baseURL).toString();
     let forGetInfoURLRequest = new Request(thisRouteBaseURL);
-    if (beforeRequestHook) {
-      const maybeRequest = beforeRequestHook(forGetInfoURLRequest);
-      if (!maybeRequest) {
-        continue;
-      }
-      forGetInfoURLRequest = maybeRequest;
-    }
     yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
       try {
+        if (beforeRequestHook) {
+          const maybeRequest = await beforeRequestHook(forGetInfoURLRequest);
+          if (!maybeRequest) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest = maybeRequest;
+        }
         await pool.run(() => app.fetch(forGetInfoURLRequest));
         if (!forGetInfoURLRequest.ssgParams) {
           if (isDynamicRoute(route.path)) {
@@ -111,7 +112,7 @@ const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook,
                     return;
                   }
                   if (afterResponseHook) {
-                    const maybeResponse = afterResponseHook(response);
+                    const maybeResponse = await afterResponseHook(response);
                     if (!maybeResponse) {
                       resolveReq(void 0);
                       return;

package/dist/cjs/helper.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,6 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var helper_exports = {};
+__export(helper_exports, {
+  jwtDecode: () => import_jwt.decode,
+  jwtSign: () => import_jwt.sign,
+  jwtVerify: () => import_jwt.verify
+});
 module.exports = __toCommonJS(helper_exports);
 __reExport(helper_exports, require("./helper/accepts"), module.exports);
 __reExport(helper_exports, require("./helper/adapter"), module.exports);
@@ -26,3 +35,10 @@ __reExport(helper_exports, require("./helper/testing"), module.exports);
 __reExport(helper_exports, require("./helper/dev"), module.exports);
 __reExport(helper_exports, require("./adapter/deno/ssg"), module.exports);
 __reExport(helper_exports, require("./adapter/deno/websocket"), module.exports);
+var import_jwt = require("./middleware/jwt");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwtDecode,
+  jwtSign,
+  jwtVerify
+});

package/dist/cjs/jsx/base.js

@@ -135,7 +135,9 @@ class JSXNode {
           const property = k.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
           return `${property}:${v[k]}`;
         }).join(";");
-        buffer[0] += ` style="${styles}"`;
+        buffer[0] += ' style="';
+        (0, import_html2.escapeToBuffer)(styles, buffer);
+        buffer[0] += '"';
       } else if (typeof v === "string") {
         buffer[0] += ` ${key}="`;
         (0, import_html2.escapeToBuffer)(v, buffer);
@@ -165,7 +167,7 @@ class JSXNode {
         buffer[0] += '"';
       }
     }
-    if (emptyTags.includes(tag)) {
+    if (emptyTags.includes(tag) && children.length === 0) {
       buffer[0] += "/>";
       return;
     }

package/dist/cjs/jsx/components.js

@@ -29,7 +29,7 @@ var import_components = require("./dom/components");
 let errorBoundaryCounter = 0;
 const childrenToString = async (children) => {
   try {
-    return children.map((c) => c.toString());
+    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
       await e;
@@ -53,7 +53,9 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
   };
   let resArray = [];
   try {
-    resArray = children.map((c) => c.toString());
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
   } catch (e) {
     fallbackStr = await fallback?.toString();
     if (e instanceof Promise) {

package/dist/cjs/jsx/hooks/index.js

@@ -294,7 +294,7 @@ const useMemo = (factory, deps) => {
   }
   return memoArray[hookIndex][0];
 };
-const useDebugValue = (value, formatter) => {
+const useDebugValue = (_value, _formatter) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/jsx/streaming.js

@@ -48,7 +48,9 @@ const Suspense = async ({
   try {
     stackNode[import_constants.DOM_STASH][0] = 0;
     import_render.buildDataStack.push([[], stackNode]);
-    resArray = children.map((c) => c.toString());
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
   } catch (e) {
     if (e instanceof Promise) {
       resArray = [

package/dist/cjs/router/reg-exp-router/router.js

@@ -30,7 +30,10 @@ const nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 let wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
   return wildcardRegExpCache[path] ??= new RegExp(
-    path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`
+    path === "*" ? "" : `^${path.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
   );
 }
 function clearWildcardRegExpCache() {

package/dist/cjs/validator/validator.js

@@ -28,6 +28,7 @@ const validator = (target, validationFunc) => {
   return async (c, next) => {
     let value = {};
     const contentType = c.req.header("Content-Type");
+    const bodyTypes = ["text", "arrayBuffer", "blob"];
     switch (target) {
       case "json":
         if (!contentType || !contentType.startsWith("application/json")) {
@@ -35,11 +36,19 @@ const validator = (target, validationFunc) => {
           throw new import_http_exception.HTTPException(400, { message });
         }
         if (c.req.bodyCache.json) {
-          value = await c.req.bodyCache.json;
+          value = c.req.bodyCache.json;
           break;
         }
         try {
-          const arrayBuffer = c.req.bodyCache.arrayBuffer ?? await c.req.raw.arrayBuffer();
+          let arrayBuffer = void 0;
+          for (const type of bodyTypes) {
+            const body = c.req.bodyCache[type];
+            if (body) {
+              arrayBuffer = await new Response(await body).arrayBuffer();
+              break;
+            }
+          }
+          arrayBuffer ??= await c.req.raw.arrayBuffer();
           value = await new Response(arrayBuffer).json();
           c.req.bodyCache.json = value;
           c.req.bodyCache.arrayBuffer = arrayBuffer;
@@ -49,23 +58,31 @@ const validator = (target, validationFunc) => {
         }
         break;
       case "form": {
+        if (!contentType) {
+          break;
+        }
         if (c.req.bodyCache.formData) {
           value = c.req.bodyCache.formData;
           break;
         }
         try {
-          const contentType2 = c.req.header("Content-Type");
-          if (contentType2) {
-            const arrayBuffer = c.req.bodyCache.arrayBuffer ?? await c.req.raw.arrayBuffer();
-            const formData = await (0, import_buffer.bufferToFormData)(arrayBuffer, contentType2);
-            const form = {};
-            formData.forEach((value2, key) => {
-              form[key] = value2;
-            });
-            value = form;
-            c.req.bodyCache.formData = formData;
-            c.req.bodyCache.arrayBuffer = arrayBuffer;
+          let arrayBuffer = void 0;
+          for (const type of bodyTypes) {
+            const body = c.req.bodyCache[type];
+            if (body) {
+              arrayBuffer = await new Response(await body).arrayBuffer();
+              break;
+            }
           }
+          arrayBuffer ??= await c.req.arrayBuffer();
+          const formData = await (0, import_buffer.bufferToFormData)(arrayBuffer, contentType);
+          const form = {};
+          formData.forEach((value2, key) => {
+            form[key] = value2;
+          });
+          value = form;
+          c.req.bodyCache.formData = formData;
+          c.req.bodyCache.arrayBuffer = arrayBuffer;
         } catch (e) {
           let message = "Malformed FormData request.";
           message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;

package/dist/helper/ssg/ssg.js

@@ -50,15 +50,16 @@ var fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, c
   for (const route of filterStaticGenerateRoutes(app)) {
     const thisRouteBaseURL = new URL(route.path, baseURL).toString();
     let forGetInfoURLRequest = new Request(thisRouteBaseURL);
-    if (beforeRequestHook) {
-      const maybeRequest = beforeRequestHook(forGetInfoURLRequest);
-      if (!maybeRequest) {
-        continue;
-      }
-      forGetInfoURLRequest = maybeRequest;
-    }
     yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
       try {
+        if (beforeRequestHook) {
+          const maybeRequest = await beforeRequestHook(forGetInfoURLRequest);
+          if (!maybeRequest) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest = maybeRequest;
+        }
         await pool.run(() => app.fetch(forGetInfoURLRequest));
         if (!forGetInfoURLRequest.ssgParams) {
           if (isDynamicRoute(route.path)) {
@@ -87,7 +88,7 @@ var fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, c
                     return;
                   }
                   if (afterResponseHook) {
-                    const maybeResponse = afterResponseHook(response);
+                    const maybeResponse = await afterResponseHook(response);
                     if (!maybeResponse) {
                       resolveReq(void 0);
                       return;

package/dist/helper.js

@@ -10,3 +10,9 @@ export * from "./helper/testing/index.js";
 export * from "./helper/dev/index.js";
 export * from "./adapter/deno/ssg.js";
 export * from "./adapter/deno/websocket.js";
+import { decode, sign, verify } from "./middleware/jwt/index.js";
+export {
+  decode as jwtDecode,
+  sign as jwtSign,
+  verify as jwtVerify
+};

package/dist/jsx/base.js

@@ -106,7 +106,9 @@ var JSXNode = class {
           const property = k.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
           return `${property}:${v[k]}`;
         }).join(";");
-        buffer[0] += ` style="${styles}"`;
+        buffer[0] += ' style="';
+        escapeToBuffer(styles, buffer);
+        buffer[0] += '"';
       } else if (typeof v === "string") {
         buffer[0] += ` ${key}="`;
         escapeToBuffer(v, buffer);
@@ -136,7 +138,7 @@ var JSXNode = class {
         buffer[0] += '"';
       }
     }
-    if (emptyTags.includes(tag)) {
+    if (emptyTags.includes(tag) && children.length === 0) {
       buffer[0] += "/>";
       return;
     }

package/dist/jsx/components.js

@@ -6,7 +6,7 @@ import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
 var errorBoundaryCounter = 0;
 var childrenToString = async (children) => {
   try {
-    return children.map((c) => c.toString());
+    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
       await e;
@@ -30,7 +30,9 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
   };
   let resArray = [];
   try {
-    resArray = children.map((c) => c.toString());
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
   } catch (e) {
     fallbackStr = await fallback?.toString();
     if (e instanceof Promise) {

package/dist/jsx/hooks/index.js

@@ -258,7 +258,7 @@ var useMemo = (factory, deps) => {
   }
   return memoArray[hookIndex][0];
 };
-var useDebugValue = (value, formatter) => {
+var useDebugValue = (_value, _formatter) => {
 };
 export {
   STASH_EFFECT,

package/dist/jsx/streaming.js

@@ -25,7 +25,9 @@ var Suspense = async ({
   try {
     stackNode[DOM_STASH][0] = 0;
     buildDataStack.push([[], stackNode]);
-    resArray = children.map((c) => c.toString());
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
   } catch (e) {
     if (e instanceof Promise) {
       resArray = [

package/dist/router/reg-exp-router/router.js

@@ -12,7 +12,10 @@ var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
   return wildcardRegExpCache[path] ??= new RegExp(
-    path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`
+    path === "*" ? "" : `^${path.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
   );
 }
 function clearWildcardRegExpCache() {

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

@@ -21,8 +21,8 @@ export interface ToSSGResult {
     files: string[];
     error?: Error;
 }
-export type BeforeRequestHook = (req: Request) => Request | false;
-export type AfterResponseHook = (res: Response) => Response | false;
+export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
+export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
 export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
 export interface ToSSGOptions {
     dir?: string;

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

@@ -1,4 +1,5 @@
+import type { ExecutionContext } from '../../context';
 import type { Hono } from '../../hono';
 type ExtractEnv<T> = T extends Hono<infer E, any, any> ? E : never;
-export declare const testClient: <T extends Hono<any, any, any>>(app: T, Env?: {} | ExtractEnv<T>["Bindings"] | undefined, executionCtx?: any) => import("../../utils/types").UnionToIntersection<import("../../client/types").Client<T>>;
+export declare const testClient: <T extends Hono<any, any, any>>(app: T, Env?: {} | ExtractEnv<T>["Bindings"] | undefined, executionCtx?: ExecutionContext) => import("../../utils/types").UnionToIntersection<import("../../client/types").Client<T>>;
 export {};

package/dist/types/jsx/base.d.ts

@@ -15,7 +15,7 @@ declare global {
     }
 }
 type LocalContexts = [Context<unknown>, unknown][];
-export type Child = string | Promise<string> | number | JSXNode | Child[];
+export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
 export declare class JSXNode implements HtmlEscaped {
     tag: string | Function;
     props: Props;
@@ -35,7 +35,7 @@ export declare const jsxFn: (tag: string | Function, props: Props, children: (st
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: ({ children, }: {
     key?: string | undefined;
-    children?: HtmlEscapedString | Child | undefined;
+    children?: Child | HtmlEscapedString;
 }) => HtmlEscapedString;
 export declare const isValidElement: (element: unknown) => element is JSXNode;
 export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;

package/dist/types/jsx/dom/index.d.ts

@@ -22,12 +22,12 @@ declare const _default: {
     useMemo: <T_5>(factory: () => T_5, deps: readonly unknown[]) => T_5;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
     useReducer: <T_6, A>(reducer: (state: T_6, action: A) => T_6, initialArg: T_6, init?: ((initialState: T_6) => T_6) | undefined) => [T_6, (action: A) => void];
-    useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
+    useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
     Suspense: import("../base").FC<import("..").PropsWithChildren<{
         fallback: any;
     }>>;
     ErrorBoundary: import("../base").FC<import("..").PropsWithChildren<{
-        fallback?: Child | undefined;
+        fallback?: Child;
         fallbackRender?: import("../components").FallbackRender | undefined;
         onError?: import("../components").ErrorHandler | undefined;
     }>>;

package/dist/types/jsx/hooks/index.d.ts

@@ -25,5 +25,5 @@ export type RefObject<T> = {
 export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
-export declare const useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
+export declare const useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
 export {};

package/dist/types/jsx/index.d.ts

@@ -8,13 +8,13 @@ declare const _default: {
     memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
     Fragment: ({ children, }: {
         key?: string | undefined;
-        children?: import("../utils/html").HtmlEscapedString | import("./base").Child | undefined;
+        children?: import("../utils/html").HtmlEscapedString | import("./base").Child;
     }) => import("../utils/html").HtmlEscapedString;
     isValidElement: (element: unknown) => element is import("./base").JSXNode;
     createElement: (tag: string | Function, props: import("./base").Props, ...children: (string | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
     cloneElement: <T_1 extends import("./base").JSXNode | JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
     ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
-        fallback?: import("./base").Child | undefined;
+        fallback?: import("./base").Child;
         fallbackRender?: import("./components").FallbackRender | undefined;
         onError?: import("./components").ErrorHandler | undefined;
     }>>;
@@ -25,7 +25,7 @@ declare const _default: {
     useRef: <T_5>(initialValue: T_5 | null) => import("./hooks").RefObject<T_5>;
     useCallback: <T_6 extends (...args: unknown[]) => unknown>(callback: T_6, deps: readonly unknown[]) => T_6;
     useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => void];
-    useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
+    useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
     use: <T_8>(promise: Promise<T_8>) => T_8;
     startTransition: (callback: () => void) => void;
     useTransition: () => [boolean, (callback: () => void) => void];

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
-import type { IfAnyThenEmptyObject, RemoveBlankRecord, UnionToIntersection } from './utils/types';
+import type { IfAnyThenEmptyObject, Prettify, RemoveBlankRecord, UnionToIntersection } from './utils/types';
 export type Bindings = Record<string, unknown>;
 export type Variables = Record<string, unknown>;
 export type Env = {
@@ -27,10 +27,26 @@ export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response |
 export type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = {}, BasePath extends string = '/'> {
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
+        H<E2, MergedPath, I>,
+        H<E3, MergedPath, I2>,
+        H<E4, MergedPath, I3>,
+        H<E5, MergedPath, I4, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4>, H<E6, P, I5, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
+        H<E2, MergedPath, I>,
+        H<E3, MergedPath, I2>,
+        H<E4, MergedPath, I3>,
+        H<E5, MergedPath, I4>,
+        H<E6, MergedPath, I5, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -39,6 +55,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, P, I5>,
         H<E7, P, I6, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, 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>,
+        H<E7, MergedPath, I6, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -48,6 +72,15 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E7, P, I6>,
         H<E8, P, I7, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, 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>,
+        H<E8, MergedPath, I7, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -58,6 +91,16 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E8, P, I7>,
         H<E9, P, I8, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, 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>,
+        H<E9, MergedPath, I8, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -69,6 +112,17 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E9, P, I8>,
         H<E10, P, I9, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, 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>,
+        H<E10, MergedPath, I9, R>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -81,62 +135,6 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E10, P, I9>,
         H<E11, P, I10, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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>, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, 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>,
-        H<E7, MergedPath, I6, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, 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>,
-        H<E8, MergedPath, I7, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, 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>,
-        H<E9, MergedPath, I8, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, 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>,
-        H<E10, MergedPath, I9, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = 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 = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -148,8 +146,10 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
     <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
@@ -359,14 +359,14 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
     <I extends Input = BlankInput, R extends HandlerResponse<any> = any>(methods: string | string[], paths: string[], ...handlers: H<E, any, I, R>[]): Hono<E, S & ToSchema<string, string, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
-export type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {
+export type ToSchema<M extends string, P extends string, I extends Input['in'], O> = Prettify<{
     [K in P]: {
         [K2 in M as AddDollar<K2>]: {
             input: unknown extends I ? AddParam<{}, P> : AddParam<I, P>;
             output: unknown extends O ? {} : O;
         };
     };
-};
+}>;
 export type Schema = {
     [Path: string]: {
         [Method: `$${Lowercase<string>}`]: {
@@ -377,15 +377,15 @@ export type Schema = {
         };
     };
 };
-type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
     [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
-} : Path extends `${infer Start}:${infer Param}` ? {
+} : Path extends `${infer _Start}:${infer Param}` ? {
     [K in Param]: string;
 } : never;
 type FlattenIfIntersect<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
-export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
+export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = Prettify<{
     [P in keyof OrigSchema as MergePath<SubPath, P & string>]: {
         [M in keyof OrigSchema[P]]: OrigSchema[P][M] extends {
             input: infer Input;
@@ -405,7 +405,7 @@ export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> =
             output: Output;
         } : never;
     };
-};
+}>;
 export type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I extends {
     param: infer _;
 } ? I : I & {
@@ -417,8 +417,7 @@ export type TypedResponse<T = unknown> = {
     data: T;
     format: 'json';
 };
-type ExtractResponseData<T> = T extends Promise<infer T2> ? T2 extends TypedResponse<infer U> ? U : {} : T extends TypedResponse<infer U> ? U : {};
-type MergeTypedResponseData<T> = ExtractResponseData<T>;
+type MergeTypedResponseData<T> = T extends Promise<infer T2> ? T2 extends TypedResponse<infer U> ? U : {} : T extends TypedResponse<infer U> ? U : {};
 export type ValidationTargets = {
     json: any;
     form: Record<string, string | File>;

package/dist/types/utils/types.d.ts

@@ -23,3 +23,6 @@ export type RequiredKeysOf<BaseType extends object> = Exclude<{
 }[keyof BaseType], undefined>;
 export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
 export type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/validator/validator.js

@@ -6,6 +6,7 @@ var validator = (target, validationFunc) => {
   return async (c, next) => {
     let value = {};
     const contentType = c.req.header("Content-Type");
+    const bodyTypes = ["text", "arrayBuffer", "blob"];
     switch (target) {
       case "json":
         if (!contentType || !contentType.startsWith("application/json")) {
@@ -13,11 +14,19 @@ var validator = (target, validationFunc) => {
           throw new HTTPException(400, { message });
         }
         if (c.req.bodyCache.json) {
-          value = await c.req.bodyCache.json;
+          value = c.req.bodyCache.json;
           break;
         }
         try {
-          const arrayBuffer = c.req.bodyCache.arrayBuffer ?? await c.req.raw.arrayBuffer();
+          let arrayBuffer = void 0;
+          for (const type of bodyTypes) {
+            const body = c.req.bodyCache[type];
+            if (body) {
+              arrayBuffer = await new Response(await body).arrayBuffer();
+              break;
+            }
+          }
+          arrayBuffer ??= await c.req.raw.arrayBuffer();
           value = await new Response(arrayBuffer).json();
           c.req.bodyCache.json = value;
           c.req.bodyCache.arrayBuffer = arrayBuffer;
@@ -27,23 +36,31 @@ var validator = (target, validationFunc) => {
         }
         break;
       case "form": {
+        if (!contentType) {
+          break;
+        }
         if (c.req.bodyCache.formData) {
           value = c.req.bodyCache.formData;
           break;
         }
         try {
-          const contentType2 = c.req.header("Content-Type");
-          if (contentType2) {
-            const arrayBuffer = c.req.bodyCache.arrayBuffer ?? await c.req.raw.arrayBuffer();
-            const formData = await bufferToFormData(arrayBuffer, contentType2);
-            const form = {};
-            formData.forEach((value2, key) => {
-              form[key] = value2;
-            });
-            value = form;
-            c.req.bodyCache.formData = formData;
-            c.req.bodyCache.arrayBuffer = arrayBuffer;
+          let arrayBuffer = void 0;
+          for (const type of bodyTypes) {
+            const body = c.req.bodyCache[type];
+            if (body) {
+              arrayBuffer = await new Response(await body).arrayBuffer();
+              break;
+            }
           }
+          arrayBuffer ??= await c.req.arrayBuffer();
+          const formData = await bufferToFormData(arrayBuffer, contentType);
+          const form = {};
+          formData.forEach((value2, key) => {
+            form[key] = value2;
+          });
+          value = form;
+          c.req.bodyCache.formData = formData;
+          c.req.bodyCache.arrayBuffer = arrayBuffer;
         } catch (e) {
           let message = "Malformed FormData request.";
           message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",