hono 3.5.8 → 3.6.0-rc.2

package/dist/adapter/vercel/handler.js

@@ -1,6 +1,15 @@
 // src/adapter/vercel/handler.ts
-var handle = (app) => (req) => {
-  return app.fetch(req);
+var handle = (app) => (req, requestContext) => {
+  return app.fetch(
+    req,
+    {},
+    {
+      waitUntil: requestContext?.waitUntil,
+      passThroughOnException: () => {
+        throw new Error("`passThroughOnException` is not implemented in the Vercel");
+      }
+    }
+  );
 };
 export {
   handle

package/dist/cjs/adapter/vercel/handler.js

@@ -21,8 +21,17 @@ __export(handler_exports, {
   handle: () => handle
 });
 module.exports = __toCommonJS(handler_exports);
-const handle = (app) => (req) => {
-  return app.fetch(req);
+const handle = (app) => (req, requestContext) => {
+  return app.fetch(
+    req,
+    {},
+    {
+      waitUntil: requestContext?.waitUntil,
+      passThroughOnException: () => {
+        throw new Error("`passThroughOnException` is not implemented in the Vercel");
+      }
+    }
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client/client.js

@@ -108,7 +108,7 @@ class ClientRequestImpl {
     this.method = method;
   }
 }
-const hc = (baseUrl, options) => createProxy(async (opts) => {
+const hc = (baseUrl, options) => createProxy((opts) => {
   const parts = [...opts.path];
   let method = "";
   if (/^\$/.test(parts[parts.length - 1])) {
@@ -119,6 +119,9 @@ const hc = (baseUrl, options) => createProxy(async (opts) => {
   }
   const path = parts.join("/");
   const url = (0, import_utils.mergePath)(baseUrl, path);
+  if (method === "url") {
+    return new URL(url);
+  }
   const req = new ClientRequestImpl(url, method);
   if (method) {
     options ?? (options = {});

package/dist/cjs/context.js

@@ -26,13 +26,19 @@ var import_cookie = require("./utils/cookie");
 class Context {
   constructor(req, options) {
     this.env = {};
+    this._var = {};
     this.finalized = false;
     this.error = void 0;
     this._status = 200;
     this._h = void 0;
     this._pH = void 0;
     this._init = true;
+    this._renderer = (content) => this.html(content);
     this.notFoundHandler = () => new Response();
+    this.render = (...args) => this._renderer(...args);
+    this.setRenderer = (renderer) => {
+      this._renderer = renderer;
+    };
     this.header = (name, value, options) => {
       if (value === void 0) {
         if (this._h) {
@@ -72,11 +78,11 @@ class Context {
       this._status = status;
     };
     this.set = (key, value) => {
-      this._map || (this._map = {});
-      this._map[key] = value;
+      this._var ?? (this._var = {});
+      this._var[key] = value;
     };
     this.get = (key) => {
-      return this._map ? this._map[key] : void 0;
+      return this._var ? this._var[key] : void 0;
     };
     this.newResponse = (data, arg, headers) => {
       if (this._init && !headers && !arg && this._status === 200) {
@@ -144,10 +150,12 @@ class Context {
       return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
     };
     this.jsonT = (object, arg, headers) => {
+      const response = typeof arg === "number" ? this.json(object, arg, headers) : this.json(object, arg);
       return {
-        response: typeof arg === "number" ? this.json(object, arg, headers) : this.json(object, arg),
+        response,
         data: object,
-        format: "json"
+        format: "json",
+        status: response.status
       };
     };
     this.html = (html, arg, headers) => {
@@ -205,6 +213,9 @@ class Context {
     this._res = _res;
     this.finalized = true;
   }
+  get var() {
+    return { ...this._var };
+  }
   get runtime() {
     const global = globalThis;
     if (global?.Deno !== void 0) {

package/dist/cjs/middleware/bearer-auth/index.js

@@ -37,7 +37,7 @@ const bearerAuth = (options) => {
   }
   const realm = options.realm?.replace(/"/g, '\\"');
   return async (c, next) => {
-    const headerToken = c.req.headers.get("Authorization");
+    const headerToken = c.req.header("Authorization");
     if (!headerToken) {
       const res = new Response("Unauthorized", {
         status: 401,

package/dist/cjs/middleware/cors/index.js

@@ -45,7 +45,7 @@ const cors = (options) => {
     function set(key, value) {
       c.res.headers.set(key, value);
     }
-    const allowOrigin = findAllowOrigin(c.req.headers.get("origin") || "");
+    const allowOrigin = findAllowOrigin(c.req.header("origin") || "");
     if (allowOrigin) {
       set("Access-Control-Allow-Origin", allowOrigin);
     }
@@ -69,7 +69,7 @@ const cors = (options) => {
       }
       let headers = opts.allowHeaders;
       if (!headers?.length) {
-        const requestHeaders = c.req.headers.get("Access-Control-Request-Headers");
+        const requestHeaders = c.req.header("Access-Control-Request-Headers");
         if (requestHeaders) {
           headers = requestHeaders.split(/\s*,\s*/);
         }

package/dist/cjs/middleware/etag/index.js

@@ -37,7 +37,7 @@ const etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
   return async (c, next) => {
-    const ifNoneMatch = c.req.headers.get("If-None-Match");
+    const ifNoneMatch = c.req.header("If-None-Match") ?? null;
     await next();
     const res = c.res;
     let etag2 = res.headers.get("ETag");

package/dist/cjs/utils/cookie.js

@@ -25,59 +25,60 @@ __export(cookie_exports, {
 });
 module.exports = __toCommonJS(cookie_exports);
 var import_url = require("./url");
+const algorithm = { name: "HMAC", hash: "SHA-256" };
+const getCryptoKey = async (secret) => {
+  const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+};
 const makeSignature = async (value, secret) => {
-  const algorithm = { name: "HMAC", hash: "SHA-256" };
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), algorithm, false, [
-    "sign",
-    "verify"
-  ]);
-  const signature = await crypto.subtle.sign(algorithm.name, key, encoder.encode(value));
+  const key = await getCryptoKey(secret);
+  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
   return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
-const _parseCookiePairs = (cookie, name) => {
-  const pairs = cookie.split(/;\s*/g);
-  const cookiePairs = pairs.map((pairStr) => pairStr.split(/\s*=\s*([^\s]+)/));
-  if (!name)
-    return cookiePairs;
-  return cookiePairs.filter((pair) => pair[0] === name);
+const verifySignature = async (base64Signature, value, secret) => {
+  try {
+    const signatureBinStr = atob(base64Signature);
+    const signature = new Uint8Array(signatureBinStr.length);
+    for (let i = 0; i < signatureBinStr.length; i++)
+      signature[i] = signatureBinStr.charCodeAt(i);
+    return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+  } catch (e) {
+    return false;
+  }
 };
+const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
 const parse = (cookie, name) => {
-  const parsedCookie = {};
-  const unsignedCookies = _parseCookiePairs(cookie, name).filter((pair) => {
-    const valueSplit = pair[1].split(".");
-    const signature = valueSplit[1] ? (0, import_url.decodeURIComponent_)(valueSplit[1]) : void 0;
-    if (valueSplit.length === 2 && signature && signature.length === 44 && signature.endsWith("=")) {
-      return false;
-    }
-    return true;
-  });
-  for (let [key, value] of unsignedCookies) {
-    value = (0, import_url.decodeURIComponent_)(value);
-    parsedCookie[key] = value;
-  }
-  return parsedCookie;
+  const pairs = cookie.trim().split(";");
+  return pairs.reduce((parsedCookie, pairStr) => {
+    pairStr = pairStr.trim();
+    const valueStartPos = pairStr.indexOf("=");
+    if (valueStartPos === -1)
+      return parsedCookie;
+    const cookieName = pairStr.substring(0, valueStartPos).trim();
+    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName))
+      return parsedCookie;
+    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+    if (cookieValue.startsWith('"') && cookieValue.endsWith('"'))
+      cookieValue = cookieValue.slice(1, -1);
+    if (validCookieValueRegEx.test(cookieValue))
+      parsedCookie[cookieName] = (0, import_url.decodeURIComponent_)(cookieValue);
+    return parsedCookie;
+  }, {});
 };
 const parseSigned = async (cookie, secret, name) => {
   const parsedCookie = {};
-  const signedCookies = _parseCookiePairs(cookie, name).filter((pair) => {
-    const valueSplit = pair[1].split(".");
-    const signature = valueSplit[1] ? (0, import_url.decodeURIComponent_)(valueSplit[1]) : void 0;
-    if (valueSplit.length !== 2 || !signature || signature.length !== 44 || !signature.endsWith("=")) {
-      console.log("VALUE SPLIT", valueSplit);
-      return false;
-    }
-    return true;
-  });
-  for (let [key, value] of signedCookies) {
-    value = (0, import_url.decodeURIComponent_)(value);
-    const signedPair = value.split(".");
-    const signatureToCompare = await makeSignature(signedPair[0], secret);
-    if (signedPair[1] !== signatureToCompare) {
-      parsedCookie[key] = false;
+  const secretKey = await getCryptoKey(secret);
+  for (const [key, value] of Object.entries(parse(cookie, name))) {
+    const signatureStartPos = value.lastIndexOf(".");
+    if (signatureStartPos < 1)
+      continue;
+    const signedValue = value.substring(0, signatureStartPos);
+    const signature = value.substring(signatureStartPos + 1);
+    if (signature.length !== 44 || !signature.endsWith("="))
       continue;
-    }
-    parsedCookie[key] = signedPair[0];
+    const isVerified = await verifySignature(signature, signedValue, secretKey);
+    parsedCookie[key] = isVerified ? signedValue : false;
   }
   return parsedCookie;
 };

package/dist/client/client.js

@@ -86,7 +86,7 @@ var ClientRequestImpl = class {
     this.method = method;
   }
 };
-var hc = (baseUrl, options) => createProxy(async (opts) => {
+var hc = (baseUrl, options) => createProxy((opts) => {
   const parts = [...opts.path];
   let method = "";
   if (/^\$/.test(parts[parts.length - 1])) {
@@ -97,6 +97,9 @@ var hc = (baseUrl, options) => createProxy(async (opts) => {
   }
   const path = parts.join("/");
   const url = mergePath(baseUrl, path);
+  if (method === "url") {
+    return new URL(url);
+  }
   const req = new ClientRequestImpl(url, method);
   if (method) {
     options ?? (options = {});

package/dist/context.js

@@ -4,13 +4,19 @@ import { serialize } from "./utils/cookie.js";
 var Context = class {
   constructor(req, options) {
     this.env = {};
+    this._var = {};
     this.finalized = false;
     this.error = void 0;
     this._status = 200;
     this._h = void 0;
     this._pH = void 0;
     this._init = true;
+    this._renderer = (content) => this.html(content);
     this.notFoundHandler = () => new Response();
+    this.render = (...args) => this._renderer(...args);
+    this.setRenderer = (renderer) => {
+      this._renderer = renderer;
+    };
     this.header = (name, value, options) => {
       if (value === void 0) {
         if (this._h) {
@@ -50,11 +56,11 @@ var Context = class {
       this._status = status;
     };
     this.set = (key, value) => {
-      this._map || (this._map = {});
-      this._map[key] = value;
+      this._var ?? (this._var = {});
+      this._var[key] = value;
     };
     this.get = (key) => {
-      return this._map ? this._map[key] : void 0;
+      return this._var ? this._var[key] : void 0;
     };
     this.newResponse = (data, arg, headers) => {
       if (this._init && !headers && !arg && this._status === 200) {
@@ -122,10 +128,12 @@ var Context = class {
       return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
     };
     this.jsonT = (object, arg, headers) => {
+      const response = typeof arg === "number" ? this.json(object, arg, headers) : this.json(object, arg);
       return {
-        response: typeof arg === "number" ? this.json(object, arg, headers) : this.json(object, arg),
+        response,
         data: object,
-        format: "json"
+        format: "json",
+        status: response.status
       };
     };
     this.html = (html, arg, headers) => {
@@ -183,6 +191,9 @@ var Context = class {
     this._res = _res;
     this.finalized = true;
   }
+  get var() {
+    return { ...this._var };
+  }
   get runtime() {
     const global = globalThis;
     if (global?.Deno !== void 0) {

package/dist/middleware/bearer-auth/index.js

@@ -15,7 +15,7 @@ var bearerAuth = (options) => {
   }
   const realm = options.realm?.replace(/"/g, '\\"');
   return async (c, next) => {
-    const headerToken = c.req.headers.get("Authorization");
+    const headerToken = c.req.header("Authorization");
     if (!headerToken) {
       const res = new Response("Unauthorized", {
         status: 401,

package/dist/middleware/cors/index.js

@@ -23,7 +23,7 @@ var cors = (options) => {
     function set(key, value) {
       c.res.headers.set(key, value);
     }
-    const allowOrigin = findAllowOrigin(c.req.headers.get("origin") || "");
+    const allowOrigin = findAllowOrigin(c.req.header("origin") || "");
     if (allowOrigin) {
       set("Access-Control-Allow-Origin", allowOrigin);
     }
@@ -47,7 +47,7 @@ var cors = (options) => {
       }
       let headers = opts.allowHeaders;
       if (!headers?.length) {
-        const requestHeaders = c.req.headers.get("Access-Control-Request-Headers");
+        const requestHeaders = c.req.header("Access-Control-Request-Headers");
         if (requestHeaders) {
           headers = requestHeaders.split(/\s*,\s*/);
         }

package/dist/middleware/etag/index.js

@@ -15,7 +15,7 @@ var etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
   return async (c, next) => {
-    const ifNoneMatch = c.req.headers.get("If-None-Match");
+    const ifNoneMatch = c.req.header("If-None-Match") ?? null;
     await next();
     const res = c.res;
     let etag2 = res.headers.get("ETag");

package/dist/types/adapter/vercel/handler.d.ts

@@ -1,2 +1,2 @@
 import type { Hono } from '../../hono';
-export declare const handle: (app: Hono<any, any, any>) => (req: Request) => Response | Promise<Response>;
+export declare const handle: (app: Hono<any, any, any>) => (req: Request, requestContext: Omit<ExecutionContext, 'passThroughOnException'>) => Response | Promise<Response>;

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

@@ -10,6 +10,8 @@ declare type ClientRequest<S extends Schema> = {
         input: infer R;
         output: infer O;
     } ? RemoveBlankRecord<R> extends never ? (args?: {}, options?: ClientRequestOptions) => Promise<ClientResponse<O>> : (args: Omit<R, 'header' | 'cookie'>, options?: ClientRequestOptions) => Promise<ClientResponse<O>> : never;
+} & {
+    $url: () => URL;
 };
 declare type BlankRecordToNever<T> = T extends Record<infer R, unknown> ? R extends never ? never : T : never;
 export interface ClientResponse<T> {

package/dist/types/context.d.ts

@@ -13,6 +13,12 @@ export interface ExecutionContext {
 }
 export interface ContextVariableMap {
 }
+export interface ContextRenderer {
+}
+interface DefaultRenderer {
+    (content: string): Response | Promise<Response>;
+}
+declare type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
 interface Get<E extends Env> {
     <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
@@ -51,27 +57,41 @@ declare type ContextOptions<E extends Env> = {
 export declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
     req: HonoRequest<P, I['out']>;
     env: E['Bindings'];
+    private _var;
     finalized: boolean;
     error: Error | undefined;
     private _status;
     private _exCtx;
-    private _map;
     private _h;
     private _pH;
     private _res;
     private _init;
+    private _renderer;
     private notFoundHandler;
     constructor(req: HonoRequest<P, I['out']>, options?: ContextOptions<E>);
     get event(): FetchEventLike;
     get executionCtx(): ExecutionContext;
     get res(): Response;
     set res(_res: Response | undefined);
+    /**
+     * @experimental
+     * `c.render()` is an experimental feature.
+     * The API might be changed.
+     */
+    render: Renderer;
+    /**
+     * @experimental
+     * `c.setRenderer()` is an experimental feature.
+     * The API might be changed.
+     */
+    setRenderer: (renderer: Renderer) => void;
     header: (name: string, value: string | undefined, options?: {
         append?: boolean;
     }) => void;
     status: (status: StatusCode) => void;
     set: Set<E>;
     get: Get<E>;
+    get var(): Readonly<E['Variables']>;
     newResponse: NewResponse;
     body: BodyRespond;
     text: TextRespond;

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

@@ -5,12 +5,12 @@ interface GetCookie {
     (c: Context): Cookie;
 }
 interface GetSignedCookie {
-    (c: Context, secret: string, key: string): Promise<string | undefined | false>;
+    (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
     (c: Context, secret: string): Promise<SignedCookie>;
 }
 export declare const getCookie: GetCookie;
 export declare const getSignedCookie: GetSignedCookie;
 export declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;
-export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string, opt?: CookieOptions) => Promise<void>;
+export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
 export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => void;
 export {};

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from './hono';
 export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
-export type { Context, ContextVariableMap } from './context';
+export type { Context, ContextVariableMap, ContextRenderer } from './context';
 export type { HonoRequest } from './request';
 export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client';
 export { Hono };

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

@@ -23,7 +23,9 @@ export declare class JSXNode implements HtmlEscaped {
 }
 export { jsxFn as jsx };
 declare const jsxFn: (tag: string | Function, props: Props, ...children: (string | HtmlEscapedString)[]) => JSXNode;
-declare type FC<T = Props> = (props: T) => HtmlEscapedString;
+export declare type FC<T = Props> = (props: T & {
+    children?: Child;
+}) => HtmlEscapedString;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: (props: {
     key?: string;

package/dist/types/request.d.ts

@@ -58,12 +58,40 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
     get url(): string;
     get method(): string;
+    /** @deprecated
+     * Use `c.req.raw.headers` instead of `c.req.headers`. The `c.req.headers` will be removed in v4.
+     * Or you can get the header values with using `c.req.header`.
+     * @example
+     *
+     * app.get('/', (c) => {
+     *   const userAgent = c.req.header('User-Agent')
+     *   //...
+     * })
+     */
     get headers(): Headers;
+    /** @deprecated
+     * Use `c.req.raw.body` instead of `c.req.body`. The `c.req.body` will be removed in v4.
+     */
     get body(): ReadableStream<Uint8Array> | null;
+    /** @deprecated
+     * Use `c.req.raw.bodyUsed` instead of `c.req.bodyUsed`. The `c.req.bodyUsed` will be removed in v4.
+     */
     get bodyUsed(): boolean;
+    /** @deprecated
+     * Use `c.req.raw.integrity` instead of `c.req.integrity`. The `c.req.integrity` will be removed in v4.
+     */
     get integrity(): string;
+    /** @deprecated
+     * Use `c.req.raw.keepalive` instead of `c.req.keepalive`. The `c.req.keepalive` will be removed in v4.
+     */
     get keepalive(): boolean;
+    /** @deprecated
+     * Use `c.req.raw.referrer` instead of `c.req.referrer`. The `c.req.referrer` will be removed in v4.
+     */
     get referrer(): string;
+    /** @deprecated
+     * Use `c.req.raw.signal` instead of `c.req.signal`. The `c.req.signal` will be removed in v4.
+     */
     get signal(): AbortSignal;
 }
 export {};

package/dist/types/types.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
+import type { StatusCode } from './utils/http-status';
 import type { UnionToIntersection } from './utils/types';
 export declare type Bindings = Record<string, unknown>;
 export declare type Variables = Record<string, unknown>;
@@ -17,63 +18,82 @@ export declare type Input = {
 declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
 export declare type Handler<E extends Env = any, P extends string = any, I extends Input = Input, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
 export declare type MiddlewareHandler<E extends Env = any, P extends string = any, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
-export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
+export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, E2 extends Env = E, R extends HandlerResponse<any> = any> = Handler<E2, P, I, R> | MiddlewareHandler<E2, P, I>;
 export declare type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = any, S extends Schema = {}, BasePath extends string = '/'> {
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any>(...handlers: [H<E, P, I, R>, H<E, P, I, R>]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(...handlers: [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>]): Hono<E, S & ToSchema<M, P, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3>(...handlers: [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>, H<E, P, I4, R>]): Hono<E, S & ToSchema<M, P, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4>(...handlers: [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>, H<E, P, I4, R>, H<E, P, I5, R>]): Hono<E, S & ToSchema<M, P, I5['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any>(...handlers: Handler<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, handler: H<E, MergePath<BasePath, P>, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, H<E, MergePath<BasePath, P>, I, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, Temp extends Env = E>(handler: H<E, P, I, Temp, R>): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, Temp extends Env = E & E2>(...handlers: [H<E2, P, I, E2, R>, H<E3, P, I, Temp, R>]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, 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 = E, Temp extends Env = E & E2 & E3>(...handlers: [H<E2, P, I, E2, R>, H<E3, P, I2, E3, R>, H<E4, P, I3, Temp, R>]): Hono<E, S & ToSchema<M, P, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, 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 = E, Temp extends Env = E & E2 & E3 & E4>(...handlers: [
+        H<E2, P, I, E2, R>,
+        H<E3, P, I2, E3, R>,
+        H<E4, P, I3, E4, R>,
+        H<E5, P, I3, Temp, R>
+    ]): Hono<E, S & ToSchema<M, P, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = 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 = E, Temp extends Env = E & E2 & E3 & E4 & E5>(...handlers: [
+        H<E2, P, I, E2, R>,
+        H<E3, P, I2, E3, R>,
+        H<E4, P, I3, E4, R>,
+        H<E5, P, I3, E5, R>,
+        H<E6, P, I3, Temp, R>
+    ]): Hono<E, S & ToSchema<M, P, I5['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, E, 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, R extends HandlerResponse<any> = any, I extends Input = {}, Temp extends Env = E>(path: P, handler: H<E, MergePath<BasePath, P>, I, Temp, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = E, Temp extends Env = E & E2>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I, Temp, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, Temp extends Env = E & E2 & E3>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, Temp, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3>(path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>,
-        H<E, MergePath<BasePath, P>, I4, R>
+    <P extends string, 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 = E, Temp extends Env = E & E2 & E3 & E4>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, E4, R>,
+        H<E5, MergePath<BasePath, P>, I4, Temp, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4>(path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>,
-        H<E, MergePath<BasePath, P>, I4, R>,
-        H<E, MergePath<BasePath, P>, I5, R>
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = 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 = E, Temp extends Env = E & E2 & E3 & E4 & E5>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, E4, R>,
+        H<E5, MergePath<BasePath, P>, I4, E5, R>,
+        H<E6, MergePath<BasePath, P>, I5, Temp, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['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>;
+    <P extends string, I extends Input = {}, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, E, 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 = '/'> {
     (...handlers: MiddlewareHandler<E, MergePath<BasePath, ExtractKey<S>>>[]): Hono<E, S, BasePath>;
     <P extends string>(path: P, ...handlers: MiddlewareHandler<E, 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, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, H<E, MergePath<BasePath, P>, I, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(method: M, path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = E>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I, E & E2, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, 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 = E>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, E & E2 & E3, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3>(method: M, path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>,
-        H<E, MergePath<BasePath, P>, I4, R>
+    <M extends string, P extends string, 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 = E>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, E4, R>,
+        H<E5, MergePath<BasePath, P>, I4, E & E2 & E3 & E4, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I3 & I4>(method: M, path: P, ...handlers: [
-        H<E, MergePath<BasePath, P>, I, R>,
-        H<E, MergePath<BasePath, P>, I2, R>,
-        H<E, MergePath<BasePath, P>, I3, R>,
-        H<E, MergePath<BasePath, P>, I4, R>,
-        H<E, MergePath<BasePath, P>, I5, R>
+    <M extends string, P extends string, 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 = E>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, E2, R>,
+        H<E3, MergePath<BasePath, P>, I2, E3, R>,
+        H<E4, MergePath<BasePath, P>, I3, E4, R>,
+        H<E5, MergePath<BasePath, P>, I4, E5, R>,
+        H<E6, MergePath<BasePath, P>, I5, E & E2 & E3 & E4 & E5, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, 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>;
-    <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>;
+    <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, E, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, E, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 declare type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
 export declare type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {
@@ -95,7 +115,7 @@ export declare type Schema = {
     };
 };
 export declare type MergeSchemaPath<OrigSchema, SubPath extends string> = {
-    [K in keyof OrigSchema as `${SubPath}${K & string}`]: OrigSchema[K];
+    [K in keyof OrigSchema as `${MergePath<SubPath, K & string>}`]: OrigSchema[K];
 };
 export declare type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I & {
     param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
@@ -106,6 +126,7 @@ export declare type TypedResponse<T = unknown> = {
     response: Response | Promise<Response>;
     data: T;
     format: 'json';
+    status: StatusCode;
 };
 declare type ExtractResponseData<T> = T extends Promise<infer T2> ? T2 extends TypedResponse<infer U> ? U : never : T extends TypedResponse<infer U> ? U : never;
 declare type MergeTypedResponseData<T> = UnionToIntersection<ExtractResponseData<T>>;

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

@@ -11,6 +11,6 @@ export declare type CookieOptions = {
     sameSite?: 'Strict' | 'Lax' | 'None';
 };
 export declare const parse: (cookie: string, name?: string) => Cookie;
-export declare const parseSigned: (cookie: string, secret: string, name?: string) => Promise<SignedCookie>;
+export declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
 export declare const serialize: (name: string, value: string, opt?: CookieOptions) => string;
-export declare const serializeSigned: (name: string, value: string, secret: string, opt?: CookieOptions) => Promise<string>;
+export declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;

package/dist/utils/cookie.js

@@ -1,58 +1,59 @@
 // src/utils/cookie.ts
 import { decodeURIComponent_ } from "./url.js";
+var algorithm = { name: "HMAC", hash: "SHA-256" };
+var getCryptoKey = async (secret) => {
+  const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+};
 var makeSignature = async (value, secret) => {
-  const algorithm = { name: "HMAC", hash: "SHA-256" };
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), algorithm, false, [
-    "sign",
-    "verify"
-  ]);
-  const signature = await crypto.subtle.sign(algorithm.name, key, encoder.encode(value));
+  const key = await getCryptoKey(secret);
+  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
   return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
-var _parseCookiePairs = (cookie, name) => {
-  const pairs = cookie.split(/;\s*/g);
-  const cookiePairs = pairs.map((pairStr) => pairStr.split(/\s*=\s*([^\s]+)/));
-  if (!name)
-    return cookiePairs;
-  return cookiePairs.filter((pair) => pair[0] === name);
+var verifySignature = async (base64Signature, value, secret) => {
+  try {
+    const signatureBinStr = atob(base64Signature);
+    const signature = new Uint8Array(signatureBinStr.length);
+    for (let i = 0; i < signatureBinStr.length; i++)
+      signature[i] = signatureBinStr.charCodeAt(i);
+    return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+  } catch (e) {
+    return false;
+  }
 };
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
 var parse = (cookie, name) => {
-  const parsedCookie = {};
-  const unsignedCookies = _parseCookiePairs(cookie, name).filter((pair) => {
-    const valueSplit = pair[1].split(".");
-    const signature = valueSplit[1] ? decodeURIComponent_(valueSplit[1]) : void 0;
-    if (valueSplit.length === 2 && signature && signature.length === 44 && signature.endsWith("=")) {
-      return false;
-    }
-    return true;
-  });
-  for (let [key, value] of unsignedCookies) {
-    value = decodeURIComponent_(value);
-    parsedCookie[key] = value;
-  }
-  return parsedCookie;
+  const pairs = cookie.trim().split(";");
+  return pairs.reduce((parsedCookie, pairStr) => {
+    pairStr = pairStr.trim();
+    const valueStartPos = pairStr.indexOf("=");
+    if (valueStartPos === -1)
+      return parsedCookie;
+    const cookieName = pairStr.substring(0, valueStartPos).trim();
+    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName))
+      return parsedCookie;
+    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+    if (cookieValue.startsWith('"') && cookieValue.endsWith('"'))
+      cookieValue = cookieValue.slice(1, -1);
+    if (validCookieValueRegEx.test(cookieValue))
+      parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
+    return parsedCookie;
+  }, {});
 };
 var parseSigned = async (cookie, secret, name) => {
   const parsedCookie = {};
-  const signedCookies = _parseCookiePairs(cookie, name).filter((pair) => {
-    const valueSplit = pair[1].split(".");
-    const signature = valueSplit[1] ? decodeURIComponent_(valueSplit[1]) : void 0;
-    if (valueSplit.length !== 2 || !signature || signature.length !== 44 || !signature.endsWith("=")) {
-      console.log("VALUE SPLIT", valueSplit);
-      return false;
-    }
-    return true;
-  });
-  for (let [key, value] of signedCookies) {
-    value = decodeURIComponent_(value);
-    const signedPair = value.split(".");
-    const signatureToCompare = await makeSignature(signedPair[0], secret);
-    if (signedPair[1] !== signatureToCompare) {
-      parsedCookie[key] = false;
+  const secretKey = await getCryptoKey(secret);
+  for (const [key, value] of Object.entries(parse(cookie, name))) {
+    const signatureStartPos = value.lastIndexOf(".");
+    if (signatureStartPos < 1)
+      continue;
+    const signedValue = value.substring(0, signatureStartPos);
+    const signature = value.substring(signatureStartPos + 1);
+    if (signature.length !== 44 || !signature.endsWith("="))
       continue;
-    }
-    parsedCookie[key] = signedPair[0];
+    const isVerified = await verifySignature(signature, signedValue, secretKey);
+    parsedCookie[key] = isVerified ? signedValue : false;
   }
   return parsedCookie;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.5.8",
+  "version": "3.6.0-rc.2",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -10,15 +10,15 @@
     "dist"
   ],
   "scripts": {
-    "test": "jest",
+    "test": "tsc --noEmit && vitest --run",
     "test:deno": "env NAME=Deno deno test --allow-read --allow-env runtime_tests/deno",
     "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: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 jest runtime_tests/lagon/index.test.ts --roots runtime_tests/lagon --testMatch '**/*.test.ts'\"",
-    "test:node": "env NAME=Node jest --config ./runtime_tests/node/jest.config.js",
-    "test:wrangler": "jest --config ./runtime_tests/wrangler/jest.config.js",
-    "test:lambda": "env NAME=Node jest --config ./runtime_tests/lambda/jest.config.js",
-    "test:lambda-edge": "env NAME=Node jest --config ./runtime_tests/lambda-edge/jest.config.js",
+    "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",
+    "test:lambda": "env NAME=Node vitest --run --config ./runtime_tests/lambda/vitest.config.ts",
+    "test:lambda-edge": "env NAME=Node vitest --run --config ./runtime_tests/lambda-edge/vitest.config.ts",
     "test:all": "yarn test && yarn test:deno && yarn test:bun && yarn test:fastly && yarn test:lagon && yarn test:node && yarn test:wrangler && yarn test:lambda && yarn test:lambda-edge",
     "lint": "eslint --ext js,ts src runtime_tests .eslintrc.cjs",
     "lint:fix": "eslint --ext js,ts src runtime_tests .eslintrc.cjs --fix",
@@ -29,6 +29,7 @@
     "build": "rimraf dist && tsx ./build.ts && yarn copy:package.cjs.json",
     "postbuild": "publint",
     "watch": "rimraf dist && tsx ./build.ts --watch && yarn copy:package.cjs.json",
+    "coverage": "vitest --run --coverage",
     "prerelease": "yarn denoify && yarn test:deno && yarn build",
     "release": "np"
   },
@@ -386,6 +387,7 @@
     "@types/supertest": "^2.0.12",
     "@typescript-eslint/eslint-plugin": "^5.59.2",
     "@typescript-eslint/parser": "^5.59.2",
+    "@vitest/coverage-v8": "^0.34.3",
     "arg": "^5.0.2",
     "crypto-js": "^4.1.1",
     "denoify": "^1.1.1",
@@ -399,9 +401,8 @@
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-node": "^11.1.0",
     "form-data": "^4.0.0",
-    "jest": "^29.4.3",
-    "jest-environment-miniflare": "2.7.1",
-    "jest-preset-fastly-js-compute": "^0.6.1",
+    "jest": "^29.6.4",
+    "jest-preset-fastly-js-compute": "^1.3.0",
     "msw": "^1.0.0",
     "node-fetch": "2",
     "np": "^7.7.0",
@@ -410,13 +411,16 @@
     "rimraf": "^3.0.2",
     "start-server-and-test": "^1.15.2",
     "supertest": "^6.3.3",
-    "ts-jest": "^29.0.1",
+    "ts-jest": "^29.1.1",
     "tsx": "^3.11.0",
     "typescript": "^4.8.3",
+    "vitest": "^0.34.3",
+    "vitest-environment-miniflare": "^2.14.1",
     "wrangler": "^2.12.0",
     "zod": "^3.20.2"
   },
   "engines": {
     "node": ">=16.0.0"
-  }
+  },
+  "dependencies": {}
 }