hono 3.11.7 → 3.11.9

package/dist/adapter/cloudflare-workers/serve-static.js

@@ -1,7 +1,7 @@
 // src/adapter/cloudflare-workers/serve-static.ts
-import { getContentFromKVAsset } from "../../utils/cloudflare.js";
 import { getFilePath } from "../../utils/filepath.js";
 import { getMimeType } from "../../utils/mime.js";
+import { getContentFromKVAsset } from "./utils.js";
 var DEFAULT_DOCUMENT = "index.html";
 var serveStatic = (options = { root: "" }) => {
   return async (c, next) => {

package/dist/{utils/cloudflare.js → adapter/cloudflare-workers/utils.js}

@@ -1,4 +1,4 @@
-// src/utils/cloudflare.ts
+// src/adapter/cloudflare-workers/utils.ts
 var getContentFromKVAsset = async (path, options) => {
   let ASSET_MANIFEST = {};
   if (options && options.manifest) {

package/dist/cjs/adapter/cloudflare-workers/serve-static.js

@@ -21,9 +21,9 @@ __export(serve_static_exports, {
   serveStatic: () => serveStatic
 });
 module.exports = __toCommonJS(serve_static_exports);
-var import_cloudflare = require("../../utils/cloudflare");
 var import_filepath = require("../../utils/filepath");
 var import_mime = require("../../utils/mime");
+var import_utils = require("./utils");
 const DEFAULT_DOCUMENT = "index.html";
 const serveStatic = (options = { root: "" }) => {
   return async (c, next) => {
@@ -40,7 +40,7 @@ const serveStatic = (options = { root: "" }) => {
     });
     if (!path)
       return await next();
-    const content = await (0, import_cloudflare.getContentFromKVAsset)(path, {
+    const content = await (0, import_utils.getContentFromKVAsset)(path, {
       manifest: options.manifest,
       namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : void 0
     });

package/dist/cjs/{utils/cloudflare.js → adapter/cloudflare-workers/utils.js}

@@ -16,11 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cloudflare_exports = {};
-__export(cloudflare_exports, {
+var utils_exports = {};
+__export(utils_exports, {
   getContentFromKVAsset: () => getContentFromKVAsset
 });
-module.exports = __toCommonJS(cloudflare_exports);
+module.exports = __toCommonJS(utils_exports);
 const getContentFromKVAsset = async (path, options) => {
   let ASSET_MANIFEST = {};
   if (options && options.manifest) {

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

@@ -47,6 +47,8 @@ const html = (strings, ...values) => {
         } else {
           buffer[0] += tmp;
         }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
       } else {
         (0, import_html.escapeToBuffer)(child.toString(), buffer);
       }

package/dist/cjs/hono-base.js

@@ -69,6 +69,14 @@ const _Hono = class extends defineDynamicClass() {
     this.routes = [];
     this.notFoundHandler = notFoundHandler;
     this.errorHandler = errorHandler;
+    this.onError = (handler) => {
+      this.errorHandler = handler;
+      return this;
+    };
+    this.notFound = (handler) => {
+      this.notFoundHandler = handler;
+      return this;
+    };
     this.head = () => {
       console.warn("`app.head()` is no longer used. `app.get()` implicitly handles the HEAD method.");
       return this;
@@ -163,14 +171,6 @@ const _Hono = class extends defineDynamicClass() {
     subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
     return subApp;
   }
-  onError(handler) {
-    this.errorHandler = handler;
-    return this;
-  }
-  notFound(handler) {
-    this.notFoundHandler = handler;
-    return this;
-  }
   showRoutes() {
     const length = 8;
     this.routes.map((route) => {

package/dist/cjs/utils/html.js

@@ -28,16 +28,28 @@ const escapeRe = /[&<>'"]/;
 const stringBufferToString = async (buffer) => {
   let str = "";
   const callbacks = [];
-  for (let i = buffer.length - 1; i >= 0; i--) {
+  for (let i = buffer.length - 1; ; i--) {
+    str += buffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
     let r = await buffer[i];
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
+    const isEscaped = r.isEscaped;
     r = await (typeof r === "object" ? r.toString() : r);
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
-    str += r;
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
   }
   return (0, import_html.raw)(str, callbacks);
 };

package/dist/helper/html/index.js

@@ -24,6 +24,8 @@ var html = (strings, ...values) => {
         } else {
           buffer[0] += tmp;
         }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
       } else {
         escapeToBuffer(child.toString(), buffer);
       }

package/dist/hono-base.js

@@ -48,6 +48,14 @@ var _Hono = class extends defineDynamicClass() {
     this.routes = [];
     this.notFoundHandler = notFoundHandler;
     this.errorHandler = errorHandler;
+    this.onError = (handler) => {
+      this.errorHandler = handler;
+      return this;
+    };
+    this.notFound = (handler) => {
+      this.notFoundHandler = handler;
+      return this;
+    };
     this.head = () => {
       console.warn("`app.head()` is no longer used. `app.get()` implicitly handles the HEAD method.");
       return this;
@@ -142,14 +150,6 @@ var _Hono = class extends defineDynamicClass() {
     subApp._basePath = mergePath(this._basePath, path);
     return subApp;
   }
-  onError(handler) {
-    this.errorHandler = handler;
-    return this;
-  }
-  notFound(handler) {
-    this.notFoundHandler = handler;
-    return this;
-  }
   showRoutes() {
     const length = 8;
     this.routes.map((route) => {

package/dist/types/client/types.d.ts

@@ -9,7 +9,7 @@ export type ClientRequestOptions<T = unknown> = keyof T extends never ? {
     headers: T;
     fetch?: typeof fetch | HonoRequest;
 };
-type ClientRequest<S extends Schema> = {
+export type ClientRequest<S extends Schema> = {
     [M in keyof S]: S[M] extends {
         input: infer R;
         output: infer O;

package/dist/types/hono-base.d.ts

@@ -35,8 +35,8 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     private errorHandler;
     route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app?: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath>;
     basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>>;
-    onError(handler: ErrorHandler<E>): this;
-    notFound(handler: NotFoundHandler<E>): this;
+    onError: (handler: ErrorHandler<E>) => this;
+    notFound: (handler: NotFoundHandler<E>) => this;
     /**
      * @deprecated
      * Use `showRoutes()` utility methods provided by 'hono/dev' instead of `app.showRoutes()`.

package/dist/types/types.d.ts

@@ -83,22 +83,22 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
     ]): 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 = {}, 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 = {}, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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, MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, 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 = {}, 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, MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, 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 = {}, 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>,
@@ -106,7 +106,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         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, MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, 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 = {}, 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>,
@@ -115,7 +115,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         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, MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, 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 = {}, 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>,
@@ -125,7 +125,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         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, MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): 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, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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>,
@@ -136,7 +136,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         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, MergedPath, I9['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): 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, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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,7 +148,7 @@ 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergedPath, 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, I extends Input = {}, 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>;
 }
 export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
@@ -156,22 +156,22 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
     <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
 export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, 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, MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, 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>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, 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>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, 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, MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, 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, MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -179,7 +179,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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, MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -188,7 +188,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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, MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -198,7 +198,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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, MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -209,7 +209,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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, MergedPath, I9['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, 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]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -221,24 +221,24 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergedPath, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(methods: Ms, 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<Ms[number], MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(methods: Ms, 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<Ms[number], MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -246,7 +246,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -255,7 +255,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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<Ms[number], MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, 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]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -265,7 +265,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         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<Ms[number], MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, 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]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -276,7 +276,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergedPath, I9['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, 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]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -288,7 +288,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergedPath, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;

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

@@ -8,6 +8,20 @@ export type HtmlEscaped = {
     callbacks?: HtmlEscapedCallback[];
 };
 export type HtmlEscapedString = string & HtmlEscaped;
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Hono',
+ * ]
+ */
 export type StringBuffer = (string | Promise<string>)[];
 export declare const stringBufferToString: (buffer: StringBuffer) => Promise<HtmlEscapedString>;
 export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;

package/dist/utils/html.js

@@ -4,16 +4,28 @@ var escapeRe = /[&<>'"]/;
 var stringBufferToString = async (buffer) => {
   let str = "";
   const callbacks = [];
-  for (let i = buffer.length - 1; i >= 0; i--) {
+  for (let i = buffer.length - 1; ; i--) {
+    str += buffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
     let r = await buffer[i];
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
+    const isEscaped = r.isEscaped;
     r = await (typeof r === "object" ? r.toString() : r);
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
-    str += r;
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
   }
   return raw(str, callbacks);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.11.7",
+  "version": "3.11.9",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -13,7 +13,7 @@
     "test": "tsc --noEmit && vitest --run",
     "test:deno": "env NAME=Deno deno test --allow-read --allow-env runtime_tests/deno && deno test --no-lock -c runtime_tests/deno-jsx/deno.precompile.json runtime_tests/deno-jsx && deno test --no-lock -c runtime_tests/deno-jsx/deno.react-jsx.json runtime_tests/deno-jsx",
     "test:bun": "env NAME=Bun bun test --jsx-import-source ../../src/jsx runtime_tests/bun/index.test.tsx",
-    "test:fastly": "jest --config ./runtime_tests/fastly/jest.config.js",
+    "test:fastly": "vitest --run --config ./runtime_tests/fastly/vitest.config.ts",
     "test:lagon": "start-server-and-test \"lagon dev runtime_tests/lagon/index.ts -e runtime_tests/lagon/.env.lagon\" http://127.0.0.1:1234 \"yarn vitest --run runtime_tests/lagon/index.test.ts --config runtime_tests/lagon/vitest.config.ts\"",
     "test:node": "env NAME=Node vitest --run --config ./runtime_tests/node/vitest.config.ts",
     "test:wrangler": "vitest --run --config ./runtime_tests/wrangler/vitest.config.ts",
@@ -441,25 +441,22 @@
     "nodejs"
   ],
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20221111.1",
-    "@hono/eslint-config": "^0.0.2",
-    "@hono/node-server": "^1.0.2",
+    "@cloudflare/workers-types": "^4.20231121.0",
+    "@hono/eslint-config": "^0.0.3",
+    "@hono/node-server": "^1.3.3",
     "@types/crypto-js": "^4.1.1",
     "@types/glob": "^8.0.0",
-    "@types/jest": "^29.4.0",
     "@types/jsdom": "^21.1.4",
     "@types/node": "^20.8.2",
     "@types/node-fetch": "^2.6.2",
     "@types/supertest": "^2.0.12",
-    "@vitest/coverage-v8": "^0.34.3",
+    "@vitest/coverage-v8": "^1.0.4",
     "arg": "^5.0.2",
     "crypto-js": "^4.1.1",
     "denoify": "^1.6.6",
     "esbuild": "^0.15.12",
     "eslint": "^8.55.0",
     "form-data": "^4.0.0",
-    "jest": "^29.6.4",
-    "jest-preset-fastly-js-compute": "^1.3.0",
     "jsdom": "^22.1.0",
     "msw": "^1.0.0",
     "node-fetch": "2",
@@ -469,11 +466,11 @@
     "rimraf": "^3.0.2",
     "start-server-and-test": "^1.15.2",
     "supertest": "^6.3.3",
-    "ts-jest": "^29.1.1",
     "tsx": "^3.11.0",
     "typescript": "^5.3.3",
-    "vitest": "^0.34.3",
-    "wrangler": "^2.12.0",
+    "vite-plugin-fastly-js-compute": "^0.4.2",
+    "vitest": "^1.0.4",
+    "wrangler": "3.17.1",
     "zod": "^3.20.2"
   },
   "engines": {