hono 4.4.8 → 4.4.9

package/README.md

@@ -25,8 +25,7 @@
 [![codecov](https://codecov.io/github/honojs/hono/graph/badge.svg)](https://codecov.io/github/honojs/hono)
 [![Discord badge](https://img.shields.io/discord/1011308539819597844?label=Discord&logo=Discord)](https://discord.gg/KMh2eNSdxV)
 
-Hono - _**\[炎\] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for the Edges.
-It works on any JavaScript runtime: Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, AWS Lambda, Lambda@Edge, and Node.js.
+Hono - _**means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework built on Web Standards. It works on any JavaScript runtime: Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, AWS Lambda, Lambda@Edge, and Node.js.
 
 Fast, but not only fast.
 
@@ -41,7 +40,7 @@ export default app
 
 ## Quick Start
 
-```
+```bash
 npm create hono@latest
 ```
 

package/dist/cjs/context.js

@@ -22,6 +22,7 @@ __export(context_exports, {
   TEXT_PLAIN: () => TEXT_PLAIN
 });
 module.exports = __toCommonJS(context_exports);
+var import_request = require("./request");
 var import_html = require("./utils/html");
 const TEXT_PLAIN = "text/plain; charset=UTF-8";
 const setHeaders = (headers, map = {}) => {
@@ -29,30 +30,37 @@ const setHeaders = (headers, map = {}) => {
   return headers;
 };
 class Context {
-  req;
+  #rawRequest;
+  #req;
   env = {};
-  _var;
+  #var;
   finalized = false;
-  error = void 0;
+  error;
   #status = 200;
   #executionCtx;
-  #headers = void 0;
-  #preparedHeaders = void 0;
+  #headers;
+  #preparedHeaders;
   #res;
   #isFresh = true;
-  layout = void 0;
-  renderer = (content) => this.html(content);
-  notFoundHandler = () => new Response();
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #matchResult;
+  #path;
   constructor(req, options) {
-    this.req = req;
+    this.#rawRequest = req;
     if (options) {
       this.#executionCtx = options.executionCtx;
       this.env = options.env;
-      if (options.notFoundHandler) {
-        this.notFoundHandler = options.notFoundHandler;
-      }
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
     }
   }
+  get req() {
+    this.#req ??= new import_request.HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
   get event() {
     if (this.#executionCtx && "respondWith" in this.#executionCtx) {
       return this.#executionCtx;
@@ -90,11 +98,14 @@ class Context {
     this.#res = _res;
     this.finalized = true;
   }
-  render = (...args) => this.renderer(...args);
-  setLayout = (layout) => this.layout = layout;
-  getLayout = () => this.layout;
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
   setRenderer = (renderer) => {
-    this.renderer = renderer;
+    this.#renderer = renderer;
   };
   header = (name, value, options) => {
     if (value === void 0) {
@@ -136,14 +147,14 @@ class Context {
     this.#status = status;
   };
   set = (key, value) => {
-    this._var ??= {};
-    this._var[key] = value;
+    this.#var ??= {};
+    this.#var[key] = value;
   };
   get = (key) => {
-    return this._var ? this._var[key] : void 0;
+    return this.#var ? this.#var[key] : void 0;
   };
   get var() {
-    return { ...this._var };
+    return { ...this.#var };
   }
   newResponse = (data, arg, headers) => {
     if (this.#isFresh && !headers && !arg && this.#status === 200) {
@@ -238,7 +249,8 @@ class Context {
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {
-    return this.notFoundHandler(this);
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/hono-base.js

@@ -24,7 +24,6 @@ __export(hono_base_exports, {
 module.exports = __toCommonJS(hono_base_exports);
 var import_compose = require("./compose");
 var import_context = require("./context");
-var import_request = require("./request");
 var import_router = require("./router");
 var import_url = require("./utils/url");
 const COMPOSED_HANDLER = Symbol("composedHandler");
@@ -198,7 +197,9 @@ class Hono {
     }
     const path = this.getPath(request, { env });
     const matchResult = this.matchRoute(method, path);
-    const c = new import_context.Context(new import_request.HonoRequest(request, path, matchResult), {
+    const c = new import_context.Context(request, {
+      path,
+      matchResult,
       env,
       executionCtx,
       notFoundHandler: this.notFoundHandler

package/dist/cjs/middleware/timing/timing.js

@@ -46,6 +46,9 @@ const timing = (config) => {
   return async function timing2(c, next) {
     const headers = [];
     const timers = /* @__PURE__ */ new Map();
+    if (c.get("metric")) {
+      return await next();
+    }
     c.set("metric", { headers, timers });
     if (options.total) {
       startTime(c, "total", options.totalDescription);

package/dist/context.js

@@ -1,4 +1,5 @@
 // src/context.ts
+import { HonoRequest } from "./request.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "./utils/html.js";
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setHeaders = (headers, map = {}) => {
@@ -6,30 +7,37 @@ var setHeaders = (headers, map = {}) => {
   return headers;
 };
 var Context = class {
-  req;
+  #rawRequest;
+  #req;
   env = {};
-  _var;
+  #var;
   finalized = false;
-  error = void 0;
+  error;
   #status = 200;
   #executionCtx;
-  #headers = void 0;
-  #preparedHeaders = void 0;
+  #headers;
+  #preparedHeaders;
   #res;
   #isFresh = true;
-  layout = void 0;
-  renderer = (content) => this.html(content);
-  notFoundHandler = () => new Response();
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #matchResult;
+  #path;
   constructor(req, options) {
-    this.req = req;
+    this.#rawRequest = req;
     if (options) {
       this.#executionCtx = options.executionCtx;
       this.env = options.env;
-      if (options.notFoundHandler) {
-        this.notFoundHandler = options.notFoundHandler;
-      }
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
     }
   }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
   get event() {
     if (this.#executionCtx && "respondWith" in this.#executionCtx) {
       return this.#executionCtx;
@@ -67,11 +75,14 @@ var Context = class {
     this.#res = _res;
     this.finalized = true;
   }
-  render = (...args) => this.renderer(...args);
-  setLayout = (layout) => this.layout = layout;
-  getLayout = () => this.layout;
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
   setRenderer = (renderer) => {
-    this.renderer = renderer;
+    this.#renderer = renderer;
   };
   header = (name, value, options) => {
     if (value === void 0) {
@@ -113,14 +124,14 @@ var Context = class {
     this.#status = status;
   };
   set = (key, value) => {
-    this._var ??= {};
-    this._var[key] = value;
+    this.#var ??= {};
+    this.#var[key] = value;
   };
   get = (key) => {
-    return this._var ? this._var[key] : void 0;
+    return this.#var ? this.#var[key] : void 0;
   };
   get var() {
-    return { ...this._var };
+    return { ...this.#var };
   }
   newResponse = (data, arg, headers) => {
     if (this.#isFresh && !headers && !arg && this.#status === 200) {
@@ -215,7 +226,8 @@ var Context = class {
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {
-    return this.notFoundHandler(this);
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
   };
 };
 export {

package/dist/hono-base.js

@@ -1,7 +1,6 @@
 // src/hono-base.ts
 import { compose } from "./compose.js";
 import { Context } from "./context.js";
-import { HonoRequest } from "./request.js";
 import { METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from "./router.js";
 import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
 var COMPOSED_HANDLER = Symbol("composedHandler");
@@ -175,7 +174,9 @@ var Hono = class {
     }
     const path = this.getPath(request, { env });
     const matchResult = this.matchRoute(method, path);
-    const c = new Context(new HonoRequest(request, path, matchResult), {
+    const c = new Context(request, {
+      path,
+      matchResult,
       env,
       executionCtx,
       notFoundHandler: this.notFoundHandler

package/dist/middleware/timing/timing.js

@@ -21,6 +21,9 @@ var timing = (config) => {
   return async function timing2(c, next) {
     const headers = [];
     const timers = /* @__PURE__ */ new Map();
+    if (c.get("metric")) {
+      return await next();
+    }
     c.set("metric", { headers, timers });
     if (options.total) {
       startTime(c, "total", options.totalDescription);

package/dist/types/context.d.ts

@@ -1,5 +1,6 @@
-import type { HonoRequest } from './request';
-import type { Env, FetchEventLike, Input, NotFoundHandler, TypedResponse } from './types';
+import { HonoRequest } from './request';
+import type { Result } from './router';
+import type { Env, FetchEventLike, H, Input, NotFoundHandler, RouterRoute, TypedResponse } from './types';
 import type { RedirectStatusCode, StatusCode } from './utils/http-status';
 import type { IsAny, JSONParsed, JSONValue, SimplifyDeepArray } from './utils/types';
 type HeaderRecord = Record<string, string | string[]>;
@@ -154,14 +155,12 @@ type ContextOptions<E extends Env> = {
      * Handler for not found responses.
      */
     notFoundHandler?: NotFoundHandler<E>;
+    matchResult?: Result<[H, RouterRoute]>;
+    path?: string;
 };
 export declare const TEXT_PLAIN = "text/plain; charset=UTF-8";
 export declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
     #private;
-    /**
-     * `.req` is the instance of {@link HonoRequest}.
-     */
-    req: HonoRequest<P, I['out']>;
     /**
      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
      *
@@ -176,7 +175,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * ```
      */
     env: E['Bindings'];
-    private _var;
     finalized: boolean;
     /**
      * `.error` can get the error object from the middleware if the Handler throws an error.
@@ -194,16 +192,17 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * ```
      */
     error: Error | undefined;
-    private layout;
-    private renderer;
-    private notFoundHandler;
     /**
      * Creates an instance of the Context class.
      *
-     * @param req - The HonoRequest object.
+     * @param req - The Request object.
      * @param options - Optional configuration options for the context.
      */
-    constructor(req: HonoRequest<P, I['out']>, options?: ContextOptions<E>);
+    constructor(req: Request, options?: ContextOptions<E>);
+    /**
+     * `.req` is the instance of {@link HonoRequest}.
+     */
+    get req(): HonoRequest<P, I['out']>;
     /**
      * @see {@link https://hono.dev/api/context#event}
      * The FetchEvent associated with the current request.
@@ -258,7 +257,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *
      * @returns The current layout function.
      */
-    getLayout: () => Layout<{
+    getLayout: () => Layout<PropsForRenderer & {
         Layout: Layout;
     }> | undefined;
     /**

package/dist/types/types.d.ts

@@ -38,18 +38,18 @@ export interface HTTPResponseError extends Error {
 export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, 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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<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, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<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, MergeTypedResponse<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>,
@@ -57,7 +57,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         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, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<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>,
@@ -73,7 +73,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, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<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>,
@@ -91,7 +91,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, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<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>,
@@ -111,7 +111,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, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<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>,
@@ -133,7 +133,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, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<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>,
@@ -157,7 +157,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, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<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, MergeTypedResponse<R>>, BasePath>;
     <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono",
-  "version": "4.4.8",
-  "description": "Ultrafast web framework for the Edges",
+  "version": "4.4.9",
+  "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
   "module": "dist/index.js",