hono 4.4.2 → 4.4.3

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
 <a href="https://hono.dev"><b>Documentation 👉 hono.dev</b></a><br />
-<i>v4 has been released!</i> <a href="docs/MIGRATION.md">Migration guide</b>
+<i>Now supports <a href="https://jsr.io/@hono/hono">JSR</a> and <code>deno.land/x</code> is deprecated! See <a href="docs/MIGRATION.md">Migration guide</a>.</i>
 </p>
 
 <hr />
@@ -22,6 +22,7 @@
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/hono)](https://bundlephobia.com/result?p=hono)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/honojs/hono)](https://github.com/honojs/hono/pulse)
 [![GitHub last commit](https://img.shields.io/github/last-commit/honojs/hono)](https://github.com/honojs/hono/commits/main)
+[![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.

package/dist/adapter/cloudflare-workers/websocket.js

@@ -35,6 +35,7 @@ var upgradeWebSocket = (createEvents) => async (c, next) => {
   }
   server.accept?.();
   return new Response(null, {
+    status: 101,
     webSocket: client
   });
 };

package/dist/adapter/deno/serve-static.js

@@ -4,13 +4,12 @@ var { open } = Deno;
 var serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
-      let file;
       try {
-        file = await open(path);
+        const file = await open(path);
+        return file ? file.readable : null;
       } catch (e) {
         console.warn(`${e}`);
       }
-      return file ? file.readable : null;
     };
     const pathResolve = (path) => {
       return `./${path}`;

package/dist/adapter/deno/websocket.js

@@ -3,8 +3,8 @@ var upgradeWebSocket = (createEvents) => async (c, next) => {
   if (c.req.header("upgrade") !== "websocket") {
     return await next();
   }
-  const { response, socket } = Deno.upgradeWebSocket(c.req.raw);
   const events = await createEvents(c);
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw);
   const wsContext = {
     binaryType: "arraybuffer",
     close: (code, reason) => socket.close(code, reason),

package/dist/cjs/adapter/cloudflare-workers/websocket.js

@@ -57,6 +57,7 @@ const upgradeWebSocket = (createEvents) => async (c, next) => {
   }
   server.accept?.();
   return new Response(null, {
+    status: 101,
     webSocket: client
   });
 };

package/dist/cjs/adapter/deno/serve-static.js

@@ -26,13 +26,12 @@ const { open } = Deno;
 const serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
-      let file;
       try {
-        file = await open(path);
+        const file = await open(path);
+        return file ? file.readable : null;
       } catch (e) {
         console.warn(`${e}`);
       }
-      return file ? file.readable : null;
     };
     const pathResolve = (path) => {
       return `./${path}`;

package/dist/cjs/adapter/deno/websocket.js

@@ -25,8 +25,8 @@ const upgradeWebSocket = (createEvents) => async (c, next) => {
   if (c.req.header("upgrade") !== "websocket") {
     return await next();
   }
-  const { response, socket } = Deno.upgradeWebSocket(c.req.raw);
   const events = await createEvents(c);
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw);
   const wsContext = {
     binaryType: "arraybuffer",
     close: (code, reason) => socket.close(code, reason),

package/dist/cjs/hono-base.js

@@ -142,25 +142,39 @@ class Hono {
     this.notFoundHandler = handler;
     return this;
   };
-  mount(path, applicationHandler, optionHandler) {
-    const mergedPath = (0, import_url.mergePath)(this._basePath, path);
-    const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-    const handler = async (c, next) => {
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        replaceRequest = options.replaceRequest;
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
       let executionContext = void 0;
       try {
         executionContext = c.executionCtx;
       } catch {
       }
-      const options = optionHandler ? optionHandler(c) : [c.env, executionContext];
-      const optionsArray = Array.isArray(options) ? options : [options];
-      const queryStrings = (0, import_url.getQueryStrings)(c.req.url);
-      const res = await applicationHandler(
-        new Request(
-          new URL((c.req.path.slice(pathPrefixLength) || "/") + queryStrings, c.req.url),
-          c.req.raw
-        ),
-        ...optionsArray
-      );
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = (0, import_url.mergePath)(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
       if (res) {
         return res;
       }

package/dist/hono-base.js

@@ -4,7 +4,7 @@ import { Context } from "./context.js";
 import { HTTPException } from "./http-exception.js";
 import { HonoRequest } from "./request.js";
 import { METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from "./router.js";
-import { getPath, getPathNoStrict, getQueryStrings, mergePath } from "./utils/url.js";
+import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
 var COMPOSED_HANDLER = Symbol("composedHandler");
 var notFoundHandler = (c) => {
   return c.text("404 Not Found", 404);
@@ -119,25 +119,39 @@ var Hono = class {
     this.notFoundHandler = handler;
     return this;
   };
-  mount(path, applicationHandler, optionHandler) {
-    const mergedPath = mergePath(this._basePath, path);
-    const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-    const handler = async (c, next) => {
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        replaceRequest = options.replaceRequest;
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
       let executionContext = void 0;
       try {
         executionContext = c.executionCtx;
       } catch {
       }
-      const options = optionHandler ? optionHandler(c) : [c.env, executionContext];
-      const optionsArray = Array.isArray(options) ? options : [options];
-      const queryStrings = getQueryStrings(c.req.url);
-      const res = await applicationHandler(
-        new Request(
-          new URL((c.req.path.slice(pathPrefixLength) || "/") + queryStrings, c.req.url),
-          c.req.raw
-        ),
-        ...optionsArray
-      );
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
       if (res) {
         return res;
       }

package/dist/types/adapter/aws-lambda/handler.d.ts

@@ -1,7 +1,6 @@
 import type { Hono } from '../../hono';
 import type { Env, Schema } from '../../types';
-import type { ALBRequestContext, ApiGatewayRequestContext, ApiGatewayRequestContextV2 } from './custom-context';
-import type { Handler, LambdaContext } from './types';
+import type { ALBRequestContext, ApiGatewayRequestContext, ApiGatewayRequestContextV2, Handler, LambdaContext } from './types';
 export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent;
 export interface APIGatewayProxyEventV2 {
     version: string;

package/dist/types/adapter/aws-lambda/index.d.ts

@@ -4,5 +4,4 @@
  */
 export { handle, streamHandle } from './handler';
 export type { APIGatewayProxyResult, LambdaEvent } from './handler';
-export type { ApiGatewayRequestContext, ApiGatewayRequestContextV2, ALBRequestContext, } from './custom-context';
-export type { LambdaContext } from './types';
+export type { ApiGatewayRequestContext, ApiGatewayRequestContextV2, ALBRequestContext, LambdaContext, } from './types';

package/dist/types/adapter/aws-lambda/types.d.ts

@@ -40,4 +40,86 @@ export interface LambdaContext {
 }
 type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
 export type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
+interface ClientCert {
+    clientCertPem: string;
+    subjectDN: string;
+    issuerDN: string;
+    serialNumber: string;
+    validity: {
+        notBefore: string;
+        notAfter: string;
+    };
+}
+interface Identity {
+    accessKey?: string;
+    accountId?: string;
+    caller?: string;
+    cognitoAuthenticationProvider?: string;
+    cognitoAuthenticationType?: string;
+    cognitoIdentityId?: string;
+    cognitoIdentityPoolId?: string;
+    principalOrgId?: string;
+    sourceIp: string;
+    user?: string;
+    userAgent: string;
+    userArn?: string;
+    clientCert?: ClientCert;
+}
+export interface ApiGatewayRequestContext {
+    accountId: string;
+    apiId: string;
+    authorizer: {
+        claims?: unknown;
+        scopes?: unknown;
+    };
+    domainName: string;
+    domainPrefix: string;
+    extendedRequestId: string;
+    httpMethod: string;
+    identity: Identity;
+    path: string;
+    protocol: string;
+    requestId: string;
+    requestTime: string;
+    requestTimeEpoch: number;
+    resourceId?: string;
+    resourcePath: string;
+    stage: string;
+}
+interface Authorizer {
+    iam?: {
+        accessKey: string;
+        accountId: string;
+        callerId: string;
+        cognitoIdentity: null;
+        principalOrgId: null;
+        userArn: string;
+        userId: string;
+    };
+}
+export interface ApiGatewayRequestContextV2 {
+    accountId: string;
+    apiId: string;
+    authentication: null;
+    authorizer: Authorizer;
+    domainName: string;
+    domainPrefix: string;
+    http: {
+        method: string;
+        path: string;
+        protocol: string;
+        sourceIp: string;
+        userAgent: string;
+    };
+    requestId: string;
+    routeKey: string;
+    stage: string;
+    time: string;
+    timeEpoch: number;
+}
+export interface ALBRequestContext {
+    elb: {
+        targetGroupArn: string;
+    };
+}
 export {};

package/dist/types/context.d.ts

@@ -157,6 +157,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     req: HonoRequest<P, I['out']>;
     /**
      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+     *
+     * @see {@link https://hono.dev/api/context#env}
+     *
      * @example
      * ```ts
      * // Environment object for Cloudflare Workers
@@ -164,13 +167,15 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   const counter = c.env.COUNTER
      * })
      * ```
-     * @see https://hono.dev/api/context#env
      */
     env: E['Bindings'];
     private _var;
     finalized: boolean;
     /**
      * `.error` can get the error object from the middleware if the Handler throws an error.
+     *
+     * @see {@link https://hono.dev/api/context#error}
+     *
      * @example
      * ```ts
      * app.use('*', async (c, next) => {
@@ -180,7 +185,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   }
      * })
      * ```
-     * @see https://hono.dev/api/context#error
      */
     error: Error | undefined;
     private layout;
@@ -194,25 +198,22 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      */
     constructor(req: HonoRequest<P, I['out']>, options?: ContextOptions<E>);
     /**
+     * @see {@link https://hono.dev/api/context#event}
      * The FetchEvent associated with the current request.
      *
      * @throws Will throw an error if the context does not have a FetchEvent.
-     *
-     * @see https://hono.dev/api/context#event
      */
     get event(): FetchEventLike;
     /**
+     * @see {@link https://hono.dev/api/context#executionctx}
      * The ExecutionContext associated with the current request.
      *
      * @throws Will throw an error if the context does not have an ExecutionContext.
-     *
-     * @see https://hono.dev/api/context#executionctx
      */
     get executionCtx(): ExecutionContext;
     /**
+     * @see {@link https://hono.dev/api/context#res}
      * The Response object for the current request.
-     *
-     * @see https://hono.dev/api/context#res
      */
     get res(): Response;
     /**
@@ -222,7 +223,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      */
     set res(_res: Response | undefined);
     /**
-     * Renders a response within a layout.
+     * `.render()` can create a response within a layout.
+     *
+     * @see {@link https://hono.dev/api/context#render-setrenderer}
      *
      * @example
      * ```ts
@@ -230,7 +233,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.render('Hello!')
      * })
      * ```
-     * @see https://hono.dev/api/context#render-setrenderer
      */
     render: Renderer;
     /**
@@ -254,6 +256,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     }> | undefined;
     /**
      * `.setRenderer()` can set the layout in the custom middleware.
+     *
+     * @see {@link https://hono.dev/api/context#render-setrenderer}
+     *
      * @example
      * ```tsx
      * app.use('*', async (c, next) => {
@@ -269,11 +274,13 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   await next()
      * })
      * ```
-     * @see https://hono.dev/api/context#render-setrenderer
      */
     setRenderer: (renderer: Renderer) => void;
     /**
      * `.header()` can set headers.
+     *
+     * @see {@link https://hono.dev/api/context#body}
+     *
      * @example
      * ```ts
      * app.get('/welcome', (c) => {
@@ -284,7 +291,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.body('Thank you for coming')
      * })
      * ```
-     * @see https://hono.dev/api/context#body
      */
     header: (name: string, value: string | undefined, options?: {
         append?: boolean;
@@ -292,6 +298,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     status: (status: StatusCode) => void;
     /**
      * `.set()` can set the value specified by the key.
+     *
+     * @see {@link https://hono.dev/api/context#set-get}
+     *
      * @example
      * ```ts
      * app.use('*', async (c, next) => {
@@ -299,12 +308,14 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   await next()
      * })
      * ```
-     * @see https://hono.dev/api/context#set-get
   ```
      */
     set: Set<E>;
     /**
      * `.get()` can use the value specified by the key.
+     *
+     * @see {@link https://hono.dev/api/context#set-get}
+     *
      * @example
      * ```ts
      * app.get('/', (c) => {
@@ -312,16 +323,17 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.text(`The message is "${message}"`)
      * })
      * ```
-     * @see https://hono.dev/api/context#set-get
      */
     get: Get<E>;
     /**
      * `.var` can access the value of a variable.
+     *
+     * @see {@link https://hono.dev/api/context#var}
+     *
      * @example
      * ```ts
      * const result = c.var.client.oneMethod()
      * ```
-     * @see https://hono.dev/api/context#var
      */
     get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
     newResponse: NewResponse;
@@ -329,6 +341,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * `.body()` can return the HTTP response.
      * You can set headers with `.header()` and set HTTP status code with `.status`.
      * This can also be set in `.text()`, `.json()` and so on.
+     *
+     * @see {@link https://hono.dev/api/context#body}
+     *
      * @example
      * ```ts
      * app.get('/welcome', (c) => {
@@ -342,34 +357,40 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.body('Thank you for coming')
      * })
      * ```
-     * @see https://hono.dev/api/context#body
      */
     body: BodyRespond;
     /**
      * `.text()` can render text as `Content-Type:text/plain`.
+     *
+     * @see {@link https://hono.dev/api/context#text}
+     *
      * @example
      * ```ts
      * app.get('/say', (c) => {
      *   return c.text('Hello!')
      * })
      * ```
-     * @see https://hono.dev/api/context#text
      */
     text: TextRespond;
     /**
      * `.json()` can render JSON as `Content-Type:application/json`.
+     *
+     * @see {@link https://hono.dev/api/context#json}
+     *
      * @example
      * ```ts
      * app.get('/api', (c) => {
      *   return c.json({ message: 'Hello!' })
      * })
      * ```
-     * @see https://hono.dev/api/context#json
      */
     json: JSONRespond;
     html: HTMLRespond;
     /**
      * `.redirect()` can Redirect, default status code is 302.
+     *
+     * @see {@link https://hono.dev/api/context#redirect}
+     *
      * @example
      * ```ts
      * app.get('/redirect', (c) => {
@@ -379,18 +400,19 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.redirect('/', 301)
      * })
      * ```
-     * @see https://hono.dev/api/context#redirect
      */
     redirect: (location: string, status?: RedirectStatusCode) => Response;
     /**
      * `.notFound()` can return the Not Found Response.
+     *
+     * @see {@link https://hono.dev/api/context#notfound}
+     *
      * @example
      * ```ts
      * app.get('/notfound', (c) => {
      *   return c.notFound()
      * })
      * ```
-     * @see https://hono.dev/api/context#notfound
      */
     notFound: () => Response | Promise<Response>;
 }

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

@@ -16,20 +16,28 @@ type GetPath<E extends Env> = (request: Request, options?: {
 export type HonoOptions<E extends Env> = {
     /**
      * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     *
+     * @see {@link https://hono.dev/api/hono#strict-mode}
+     *
      * @default true
-     * @see https://hono.dev/api/hono#strict-mode
      */
     strict?: boolean;
     /**
      * `router` option specifices which router to use.
+     *
+     * @see {@link https://hono.dev/api/hono#router-option}
+     *
+     * @example
      * ```ts
      * const app = new Hono({ router: new RegExpRouter() })
      * ```
-     * @see https://hono.dev/api/hono#router-option
      */
     router?: Router<[H, RouterRoute]>;
     /**
      * `getPath` can handle the host header value.
+     *
+     * @see {@link https://hono.dev/api/routing#routing-with-host-header-value}
+     *
      * @example
      * ```ts
      * const app = new Hono({
@@ -44,10 +52,15 @@ export type HonoOptions<E extends Env> = {
      * //  headers: { host: 'www1.example.com' },
      * // })
      * ```
-     * @see https://hono.dev/api/routing#routing-with-host-header-value
      */
     getPath?: GetPath<E>;
 };
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+    optionHandler?: MountOptionHandler;
+    replaceRequest?: MountReplaceRequest;
+};
 declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
     #private;
     get: HandlerInterface<E, 'get', S, BasePath>;
@@ -67,18 +80,48 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     private clone;
     private notFoundHandler;
     private errorHandler;
+    /**
+     * `.route()` allows grouping other Hono instance in routes.
+     *
+     * @see {@link https://hono.dev/api/routing#grouping}
+     *
+     * @param {string} path - base Path
+     * @param {Hono} app - other Hono instance
+     * @returns {Hono} routed Hono instnace
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const app2 = new Hono()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
     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()` allows base paths to be specified.
+     *
+     * @see {@link https://hono.dev/api/routing#base-path}
+     *
+     * @param {string} path - base Path
+     * @returns {Hono} changed Hono instance
+     *
      * @example
      * ```ts
      * const api = new Hono().basePath('/api')
      * ```
-     * @see https://hono.dev/api/routing#base-path
      */
     basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>>;
     /**
      * `.onError()` handles an error and returns a customized Response.
+     *
+     * @see {@link https://hono.dev/api/hono#error-handling}
+     *
+     * @param {ErrorHandler} handler - request Handler for error
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
      * ```ts
      * app.onError((err, c) => {
      *   console.error(`${err}`)
@@ -89,39 +132,67 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath>;
     /**
      * `.notFound()` allows you to customize a Not Found Response.
+     *
+     * @see {@link https://hono.dev/api/hono#not-found}
+     *
+     * @param {NotFoundHandler} handler - request handler for not-found
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
      * ```ts
      * app.notFound((c) => {
      *   return c.text('Custom 404 Message', 404)
      * })
      * ```
-     * @see https://hono.dev/api/hono#not-found
      */
     notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath>;
     /**
-     * Mounts an external application handler to the specified path.
+     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
      *
-     * @param path - The path where the external application handler should be mounted.
-     * @param applicationHandler - The external application handler function that processes requests.
-     * @param optionHandler - Optional function to handle additional options, such as environment variables and execution context.
+     * @see {@link https://hono.dev/api/hono#mount}
      *
-     * @returns The current instance of Hono for chaining.
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Hono} mounted Hono instance
      *
      * @example
      * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Hono } from 'hono'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
      * const app = new Hono()
-     * const externalAppHandler = () => new Response('External App')
-     * app.mount('/external', externalAppHandler)
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
      * ```
-     * @see https://hono.dev/api/hono#mount
      */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, optionHandler?: (c: Context) => unknown): Hono<E, S, BasePath>;
+    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath>;
     private addRoute;
     private matchRoute;
     private handleError;
     private dispatch;
     /**
      * `.fetch()` will be entry point of your app.
-     * @see https://hono.dev/api/hono#fetch
+     *
+     * @see {@link https://hono.dev/api/hono#fetch}
+     *
+     * @param {Request} request - reuqest Object of request
+     * @param {Env} Env - env Object
+     * @param {ExecutionContext} - context of execution
+     * @returns {Response | Promise<Response>} response of request
+     *
      */
     fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**

package/dist/types/http-exception.d.ts

@@ -16,6 +16,15 @@ type HTTPExceptionOptions = {
 };
 /**
  * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
  * @example
  * ```ts
  * import { HTTPException } from 'hono/http-exception'
@@ -30,7 +39,6 @@ type HTTPExceptionOptions = {
  *   await next()
  * })
  * ```
- * @see https://hono.dev/api/exception
  */
 export declare class HTTPException extends Error {
     readonly res?: Response;

package/dist/types/request.d.ts

@@ -16,6 +16,9 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     #private;
     /**
      * `.raw` can get the raw Request object.
+     *
+     * @see {@link https://hono.dev/api/request#raw}
+     *
      * @example
      * ```ts
      * // For Cloudflare Workers
@@ -24,32 +27,35 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   ...
      * })
      * ```
-     * @see https://hono.dev/api/request#raw
      */
     raw: Request;
     routeIndex: number;
     /**
      * `.path` can get the pathname of the request.
+     *
+     * @see {@link https://hono.dev/api/request#path}
+     *
      * @example
      * ```ts
      * app.get('/about/me', (c) => {
      *   const pathname = c.req.path // `/about/me`
      * })
      * ```
-     * @see https://hono.dev/api/request#path
      */
     path: string;
     bodyCache: BodyCache;
     constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
     /**
      * `.req.param()` gets the path parameters.
+     *
+     * @see {@link https://hono.dev/api/routing#path-parameter}
+     *
      * @example
      * ```ts
      * const name = c.req.param('name')
      * // or all parameters at once
      * const { id, comment_id } = c.req.param()
      * ```
-     * @see https://hono.dev/api/routing#path-parameter
      */
     param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: P2 extends `${infer _}?` ? never : P2): string;
     param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
@@ -60,6 +66,9 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     private getParamValue;
     /**
      * `.query()` can get querystring parameters.
+     *
+     * @see {@link https://hono.dev/api/request#query}
+     *
      * @example
      * ```ts
      * // Query params
@@ -72,12 +81,14 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   const { q, limit, offset } = c.req.query()
      * })
      * ```
-     * @see https://hono.dev/api/request#query
      */
     query(key: string): string | undefined;
     query(): Record<string, string>;
     /**
      * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
+     *
+     * @see {@link https://hono.dev/api/request#queries}
+     *
      * @example
      * ```ts
      * app.get('/search', (c) => {
@@ -85,66 +96,75 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   const tags = c.req.queries('tags')
      * })
      * ```
-     * @see https://hono.dev/api/request#queries
      */
     queries(key: string): string[] | undefined;
     queries(): Record<string, string[]>;
     /**
      * `.header()` can get the request header value.
+     *
+     * @see {@link https://hono.dev/api/request#header}
+     *
      * @example
      * ```ts
      * app.get('/', (c) => {
      *   const userAgent = c.req.header('User-Agent')
      * })
      * ```
-     * @see https://hono.dev/api/request#header
      */
     header(name: string): string | undefined;
     header(): Record<string, string>;
     /**
      * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
+     *
+     * @see {@link https://hono.dev/api/request#parsebody}
+     *
      * @example
      * ```ts
      * app.post('/entry', async (c) => {
      *   const body = await c.req.parseBody()
      * })
      * ```
-     * @see https://hono.dev/api/request#parsebody
      */
     parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
     parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
     private cachedBody;
     /**
      * `.json()` can parse Request body of type `application/json`
+     *
+     * @see {@link https://hono.dev/api/request#json}
+     *
      * @example
      * ```ts
      * app.post('/entry', async (c) => {
      *   const body = await c.req.json()
      * })
      * ```
-     * @see https://hono.dev/api/request#json
      */
     json<T = any>(): Promise<T>;
     /**
      * `.text()` can parse Request body of type `text/plain`
+     *
+     * @see {@link https://hono.dev/api/request#text}
+     *
      * @example
      * ```ts
      * app.post('/entry', async (c) => {
      *   const body = await c.req.text()
      * })
      * ```
-     * @see https://hono.dev/api/request#text
      */
     text(): Promise<string>;
     /**
      * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+     *
+     * @see {@link https://hono.dev/api/request#arraybuffer}
+     *
      * @example
      * ```ts
      * app.post('/entry', async (c) => {
      *   const body = await c.req.arrayBuffer()
      * })
      * ```
-     * @see https://hono.dev/api/request#arraybuffer
      */
     arrayBuffer(): Promise<ArrayBuffer>;
     /**
@@ -187,6 +207,9 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
     /**
      * `.url()` can get the request url strings.
+     *
+     * @see {@link https://hono.dev/api/request#url}
+     *
      * @example
      * ```ts
      * app.get('/about/me', (c) => {
@@ -194,22 +217,26 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   ...
      * })
      * ```
-     * @see https://hono.dev/api/request#url
      */
     get url(): string;
     /**
      * `.method()` can get the method name of the request.
+     *
+     * @see {@link https://hono.dev/api/request#method}
+     *
      * @example
      * ```ts
      * app.get('/about/me', (c) => {
      *   const method = c.req.method // `GET`
      * })
      * ```
-     * @see https://hono.dev/api/request#method
      */
     get method(): string;
     /**
      * `.matchedRoutes()` can return a matched route in the handler
+     *
+     * @see {@link https://hono.dev/api/request#matchedroutes}
+     *
      * @example
      * ```ts
      * app.use('*', async function logger(c, next) {
@@ -227,18 +254,19 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   })
      * })
      * ```
-     * @see https://hono.dev/api/request#matchedroutes
      */
     get matchedRoutes(): RouterRoute[];
     /**
      * `routePath()` can retrieve the path registered within the handler
+     *
+     * @see {@link https://hono.dev/api/request#routepath}
+     *
      * @example
      * ```ts
      * app.get('/posts/:id', (c) => {
      *   return c.json({ path: c.req.routePath })
      * })
      * ```
-     * @see https://hono.dev/api/request#routepath
      */
     get routePath(): string;
 }

package/dist/types/utils/http-status.d.ts

@@ -9,17 +9,22 @@ export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusC
 export type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
 export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
 /**
- * `UnOfficalStatusCode` can be used to specify an informal status code.
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
  * @example
  *
  * ```ts
- * app.get('/', (c) => {
- *   return c.text("hono is cool", 666 as UnOfficalStatusCode)
+ * app.get('/unknown', (c) => {
+ *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
  * })
  * ```
  */
+export type UnofficialStatusCode = -1;
+/**
+ * @deprecated
+ * Use `UnofficialStatusCode` instead.
+ */
 export type UnOfficalStatusCode = -1;
 /**
- * If you want to use an unofficial status, use `UnOfficalStatusCode`.
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
  */
-export type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnOfficalStatusCode;
+export type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode | UnOfficalStatusCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.4.2",
+  "version": "4.4.3",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -16,10 +16,10 @@
     "test:bun": "bun test --jsx-import-source ../../src/jsx runtime_tests/bun/index.test.tsx",
     "test:fastly": "vitest --run --config ./runtime_tests/fastly/vitest.config.ts",
     "test:node": "vitest --run --config ./runtime_tests/node/vitest.config.ts",
-    "test:wrangler": "vitest --run --config ./runtime_tests/wrangler/vitest.config.ts",
+    "test:workerd": "vitest --run --config ./runtime_tests/workerd/vitest.config.ts",
     "test:lambda": "vitest --run --config ./runtime_tests/lambda/vitest.config.ts",
     "test:lambda-edge": "vitest --run --config ./runtime_tests/lambda-edge/vitest.config.ts",
-    "test:all": "bun run test && bun test:deno && bun test:bun && bun test:fastly && bun test:node && bun test:wrangler && bun test:lambda && bun test:lambda-edge",
+    "test:all": "bun run test && bun test:deno && bun test:bun && bun test:fastly && bun test:node && bun test:workerd && bun test:lambda && bun test:lambda-edge",
     "lint": "eslint --ext js,ts,tsx src runtime_tests",
     "lint:fix": "eslint --ext js,ts,tsx src runtime_tests --fix",
     "format": "prettier --check --cache \"src/**/*.{js,ts,tsx}\" \"runtime_tests/**/*.{js,ts,tsx}\"",
@@ -593,7 +593,8 @@
     "typescript": "^5.3.3",
     "vite-plugin-fastly-js-compute": "^0.4.2",
     "vitest": "^1.2.2",
-    "wrangler": "3.17.1",
+    "wrangler": "^3.58.0",
+    "ws": "^8.17.0",
     "zod": "^3.20.2"
   },
   "engines": {

package/dist/cjs/adapter/aws-lambda/custom-context.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var custom_context_exports = {};
-module.exports = __toCommonJS(custom_context_exports);

package/dist/types/adapter/aws-lambda/custom-context.d.ts

@@ -1,83 +0,0 @@
-interface ClientCert {
-    clientCertPem: string;
-    subjectDN: string;
-    issuerDN: string;
-    serialNumber: string;
-    validity: {
-        notBefore: string;
-        notAfter: string;
-    };
-}
-interface Identity {
-    accessKey?: string;
-    accountId?: string;
-    caller?: string;
-    cognitoAuthenticationProvider?: string;
-    cognitoAuthenticationType?: string;
-    cognitoIdentityId?: string;
-    cognitoIdentityPoolId?: string;
-    principalOrgId?: string;
-    sourceIp: string;
-    user?: string;
-    userAgent: string;
-    userArn?: string;
-    clientCert?: ClientCert;
-}
-export interface ApiGatewayRequestContext {
-    accountId: string;
-    apiId: string;
-    authorizer: {
-        claims?: unknown;
-        scopes?: unknown;
-    };
-    domainName: string;
-    domainPrefix: string;
-    extendedRequestId: string;
-    httpMethod: string;
-    identity: Identity;
-    path: string;
-    protocol: string;
-    requestId: string;
-    requestTime: string;
-    requestTimeEpoch: number;
-    resourceId?: string;
-    resourcePath: string;
-    stage: string;
-}
-interface Authorizer {
-    iam?: {
-        accessKey: string;
-        accountId: string;
-        callerId: string;
-        cognitoIdentity: null;
-        principalOrgId: null;
-        userArn: string;
-        userId: string;
-    };
-}
-export interface ApiGatewayRequestContextV2 {
-    accountId: string;
-    apiId: string;
-    authentication: null;
-    authorizer: Authorizer;
-    domainName: string;
-    domainPrefix: string;
-    http: {
-        method: string;
-        path: string;
-        protocol: string;
-        sourceIp: string;
-        userAgent: string;
-    };
-    requestId: string;
-    routeKey: string;
-    stage: string;
-    time: string;
-    timeEpoch: number;
-}
-export interface ALBRequestContext {
-    elb: {
-        targetGroupArn: string;
-    };
-}
-export {};