hono 4.0.10 → 4.1.0

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

@@ -1,3 +1,4 @@
+import type { UpgradedWebSocketResponseInputJSONType } from '../helper/websocket';
 import type { Hono } from '../hono';
 import type { Schema } from '../types';
 import type { HasRequiredKeys } from '../utils/types';
@@ -22,6 +23,14 @@ export type ClientRequest<S extends Schema> = {
     } ? {
         param: P;
     } : {} : {}) => URL;
+} & {
+    $ws: S['$get'] extends {
+        input: {
+            json: UpgradedWebSocketResponseInputJSONType;
+        };
+    } ? S['$get'] extends {
+        input: infer I;
+    } ? (args?: Omit<I, 'json'>) => WebSocket : never : never;
 };
 type BlankRecordToNever<T> = T extends any ? (keyof T extends never ? never : T) : never;
 export interface ClientResponse<T> {

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

@@ -1,12 +1,14 @@
 import type { Context } from '../../context';
-import type { CookieOptions, Cookie, SignedCookie } from '../../utils/cookie';
+import type { CookieOptions, Cookie, SignedCookie, CookiePrefixOptions } from '../../utils/cookie';
 interface GetCookie {
     (c: Context, key: string): string | undefined;
     (c: Context): Cookie;
+    (c: Context, key: string, prefixOptions: CookiePrefixOptions): string | undefined;
 }
 interface GetSignedCookie {
     (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
     (c: Context, secret: string): Promise<SignedCookie>;
+    (c: Context, secret: string | BufferSource, key: string, prefixOptions: CookiePrefixOptions): Promise<string | undefined | false>;
 }
 export declare const getCookie: GetCookie;
 export declare const getSignedCookie: GetSignedCookie;

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

@@ -1,105 +1,2 @@
-import type { Context } from '../../context';
-import type { Hono } from '../../hono';
-import type { Env, MiddlewareHandler, Schema } from '../../types';
-export declare const SSG_DISABLED_RESPONSE: Response;
-/**
- * @experimental
- * `FileSystemModule` is an experimental feature.
- * The API might be changed.
- */
-export interface FileSystemModule {
-    writeFile(path: string, data: string | Uint8Array): Promise<void>;
-    mkdir(path: string, options: {
-        recursive: boolean;
-    }): Promise<void | string>;
-}
-/**
- * @experimental
- * `ToSSGResult` is an experimental feature.
- * The API might be changed.
- */
-export interface ToSSGResult {
-    success: boolean;
-    files: string[];
-    error?: Error;
-}
-interface SSGParam {
-    [key: string]: string;
-}
-type SSGParams = SSGParam[];
-interface SSGParamsMiddleware {
-    <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
-    <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
-}
-/**
- * Define SSG Route
- */
-export declare const ssgParams: SSGParamsMiddleware;
-export type BeforeRequestHook = (req: Request) => Request | false;
-export type AfterResponseHook = (res: Response) => Response | false;
-export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
-export interface ToSSGOptions {
-    dir?: string;
-    beforeRequestHook?: BeforeRequestHook;
-    afterResponseHook?: AfterResponseHook;
-    afterGenerateHook?: AfterGenerateHook;
-}
-/**
- * @experimental
- * `fetchRoutesContent` is an experimental feature.
- * The API might be changed.
- */
-export declare const fetchRoutesContent: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, beforeRequestHook?: BeforeRequestHook, afterResponseHook?: AfterResponseHook) => Promise<Map<string, {
-    content: string | ArrayBuffer;
-    mimeType: string;
-}>>;
-/**
- * @experimental
- * `saveContentToFiles` is an experimental feature.
- * The API might be changed.
- */
-export declare const saveContentToFiles: (htmlMap: Map<string, {
-    content: string | ArrayBuffer;
-    mimeType: string;
-}>, fsModule: FileSystemModule, outDir: string) => Promise<string[]>;
-/**
- * @experimental
- * `ToSSGInterface` is an experimental feature.
- * The API might be changed.
- */
-export interface ToSSGInterface {
-    (app: Hono<any, any, any>, fsModule: FileSystemModule, options?: ToSSGOptions): Promise<ToSSGResult>;
-}
-/**
- * @experimental
- * `ToSSGAdaptorInterface` is an experimental feature.
- * The API might be changed.
- */
-export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
-}
-/**
- * @experimental
- * `toSSG` is an experimental feature.
- * The API might be changed.
- */
-export declare const toSSG: ToSSGInterface;
-/**
- * @experimental
- * `isSSGContext` is an experimental feature.
- * The API might be changed.
- */
-export declare const isSSGContext: (c: Context) => boolean;
-/**
- * @experimental
- * `disableSSG` is an experimental feature.
- * The API might be changed.
- */
-export declare const disableSSG: () => MiddlewareHandler;
-/**
- * @experimental
- * `onlySSG` is an experimental feature.
- * The API might be changed.
- */
-export declare const onlySSG: () => MiddlewareHandler;
-export {};
+export * from './ssg';
+export { SSG_DISABLED_RESPONSE, ssgParams, isSSGContext, disableSSG, onlySSG } from './middleware';

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

@@ -0,0 +1,38 @@
+import type { Context } from '../../context';
+import type { Env, MiddlewareHandler } from '../../types';
+export declare const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+export declare const SSG_DISABLED_RESPONSE: Response;
+interface SSGParam {
+    [key: string]: string;
+}
+export type SSGParams = SSGParam[];
+interface SSGParamsMiddleware {
+    <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
+    <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
+}
+export type AddedSSGDataRequest = Request & {
+    ssgParams?: SSGParams;
+};
+/**
+ * Define SSG Route
+ */
+export declare const ssgParams: SSGParamsMiddleware;
+/**
+ * @experimental
+ * `isSSGContext` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const isSSGContext: (c: Context) => boolean;
+/**
+ * @experimental
+ * `disableSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const disableSSG: () => MiddlewareHandler;
+/**
+ * @experimental
+ * `onlySSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const onlySSG: () => MiddlewareHandler;
+export {};

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

@@ -0,0 +1,70 @@
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+/**
+ * @experimental
+ * `FileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export interface FileSystemModule {
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    mkdir(path: string, options: {
+        recursive: boolean;
+    }): Promise<void | string>;
+}
+/**
+ * @experimental
+ * `ToSSGResult` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGResult {
+    success: boolean;
+    files: string[];
+    error?: Error;
+}
+export type BeforeRequestHook = (req: Request) => Request | false;
+export type AfterResponseHook = (res: Response) => Response | false;
+export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
+export interface ToSSGOptions {
+    dir?: string;
+    beforeRequestHook?: BeforeRequestHook;
+    afterResponseHook?: AfterResponseHook;
+    afterGenerateHook?: AfterGenerateHook;
+    concurrency?: number;
+}
+/**
+ * @experimental
+ * `fetchRoutesContent` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const fetchRoutesContent: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, beforeRequestHook?: BeforeRequestHook, afterResponseHook?: AfterResponseHook, concurrency?: number) => Generator<Promise<Generator<Promise<{
+    routePath: string;
+    mimeType: string;
+    content: string | ArrayBuffer;
+} | undefined>> | undefined>>;
+export declare const saveContentToFile: (data: Promise<{
+    routePath: string;
+    content: string | ArrayBuffer;
+    mimeType: string;
+} | undefined>, fsModule: FileSystemModule, outDir: string) => Promise<string | undefined>;
+/**
+ * @experimental
+ * `ToSSGInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGInterface {
+    (app: Hono<any, any, any>, fsModule: FileSystemModule, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `ToSSGAdaptorInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+    (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const toSSG: ToSSGInterface;

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

@@ -0,0 +1,34 @@
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+/**
+ * WebSocket Event Listeners type
+ */
+export interface WSEvents {
+    onOpen?: (evt: Event, ws: WSContext) => void;
+    onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext) => void;
+    onClose?: (evt: CloseEvent, ws: WSContext) => void;
+    onError?: (evt: Event, ws: WSContext) => void;
+}
+export type UpgradedWebSocketResponseInputJSONType = '__websocket' | undefined;
+/**
+ * Upgrade WebSocket Type
+ */
+export type UpgradeWebSocket = (createEvents: (c: Context) => WSEvents | Promise<WSEvents>) => MiddlewareHandler<any, string, {
+    in: {
+        json: UpgradedWebSocketResponseInputJSONType;
+    };
+}>;
+export type WSReadyState = 0 | 1 | 2 | 3;
+export type WSContext = {
+    send(source: string | ArrayBuffer | Uint8Array, options?: {
+        compress: boolean;
+    }): void;
+    raw?: unknown;
+    binaryType: BinaryType;
+    readyState: WSReadyState;
+    url: URL | null;
+    protocol: string | null;
+    close(code?: number, reason?: string): void;
+};
+export type WSMessageReceive = string | Blob | ArrayBufferLike;
+export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;

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

@@ -2,6 +2,7 @@ import type { StatusCode } from './utils/http-status';
 type HTTPExceptionOptions = {
     res?: Response;
     message?: string;
+    cause?: unknown;
 };
 /**
  * `HTTPException` must be used when a fatal error such as authentication failure occurs.

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

@@ -1,9 +1,42 @@
-export { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, } from '../hooks';
+import type { Props, Child, JSXNode } from '../base';
+import { memo, isValidElement } from '../base';
+import { useContext } from '../context';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue } from '../hooks';
+import { Suspense, ErrorBoundary } from './components';
+import { createContext } from './context';
 export { render } from './render';
-export { Suspense, ErrorBoundary } from './components';
-export { useContext } from '../context';
+declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props, ...children: Child[]) => JSXNode;
+declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
+export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, };
+declare const _default: {
+    useState: <T>(initialState: T | (() => T)) => [T, (newState: T | ((currentState: T) => T)) => void];
+    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    useRef: <T_1>(initialValue: T_1 | null) => import("../hooks").RefObject<T_1>;
+    useCallback: <T_2 extends (...args: unknown[]) => unknown>(callback: T_2, deps: readonly unknown[]) => T_2;
+    use: <T_3>(promise: Promise<T_3>) => T_3;
+    startTransition: (callback: () => void) => void;
+    useTransition: () => [boolean, (callback: () => void) => void];
+    useDeferredValue: <T_4>(value: T_4) => T_4;
+    startViewTransition: (callback: () => void) => void;
+    useViewTransition: () => [boolean, (callback: () => void) => void];
+    useMemo: <T_5>(factory: () => T_5, deps: readonly unknown[]) => T_5;
+    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    useReducer: <T_6, A>(reducer: (state: T_6, action: A) => T_6, initialArg: T_6, init?: ((initialState: T_6) => T_6) | undefined) => [T_6, (action: A) => void];
+    useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
+    Suspense: import("../base").FC<import("..").PropsWithChildren<{
+        fallback: any;
+    }>>;
+    ErrorBoundary: import("../base").FC<import("..").PropsWithChildren<{
+        fallback?: Child | undefined;
+        fallbackRender?: import("../components").FallbackRender | undefined;
+        onError?: import("../components").ErrorHandler | undefined;
+    }>>;
+    createContext: <T_7>(defaultValue: T_7) => import("../context").Context<T_7>;
+    useContext: <T_8>(context: import("../context").Context<T_8>) => T_8;
+    memo: <T_9>(component: import("../base").FC<T_9>, propsAreEqual?: (prevProps: Readonly<T_9>, nextProps: Readonly<T_9>) => boolean) => import("../base").FC<T_9>;
+    isValidElement: (element: unknown) => element is JSXNode;
+    createElement: (tag: string | ((props: Props) => JSXNode), props: Props, ...children: Child[]) => JSXNode;
+    cloneElement: <T_10 extends JSXNode | JSX.Element>(element: T_10, props: Props, ...children: Child[]) => T_10;
+};
+export default _default;
 export type { Context } from '../context';
-export { createContext } from './context';
-export { memo, isValidElement } from '../base';
-import type { Props, Child, JSXNode } from '../base';
-export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;

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

@@ -15,6 +15,7 @@ export declare const startTransition: (callback: () => void) => void;
 export declare const useTransition: () => [boolean, (callback: () => void) => void];
 export declare const useDeferredValue: <T>(value: T) => T;
 export declare const useState: <T>(initialState: T | (() => T)) => [T, UpdateStateFunction<T>];
+export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: ((initialState: T) => T) | undefined) => [T, (action: A) => void];
 export declare const useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useCallback: <T extends (...args: unknown[]) => unknown>(callback: T, deps: readonly unknown[]) => T;
@@ -24,4 +25,5 @@ export type RefObject<T> = {
 export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+export declare const useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
 export {};

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

@@ -1,6 +1,42 @@
-export { jsx, memo, Fragment, isValidElement, cloneElement } from './base';
-export { ErrorBoundary } from './components';
-export { Suspense } from './streaming';
-export { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, } from './hooks';
-export { createContext, useContext } from './context';
+import { jsx, memo, Fragment, isValidElement, cloneElement } from './base';
+import { ErrorBoundary } from './components';
+import { createContext, useContext } from './context';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue } from './hooks';
+import { Suspense } from './streaming';
+export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, Suspense, };
+declare const _default: {
+    memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
+    Fragment: ({ children, }: {
+        key?: string | undefined;
+        children?: import("../utils/html").HtmlEscapedString | import("./base").Child | undefined;
+    }) => import("../utils/html").HtmlEscapedString;
+    isValidElement: (element: unknown) => element is import("./base").JSXNode;
+    createElement: (tag: string | Function, props: import("./base").Props, ...children: (string | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
+    cloneElement: <T_1 extends import("./base").JSXNode | JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
+    ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
+        fallback?: import("./base").Child | undefined;
+        fallbackRender?: import("./components").FallbackRender | undefined;
+        onError?: import("./components").ErrorHandler | undefined;
+    }>>;
+    createContext: <T_2>(defaultValue: T_2) => import("./context").Context<T_2>;
+    useContext: <T_3>(context: import("./context").Context<T_3>) => T_3;
+    useState: <T_4>(initialState: T_4 | (() => T_4)) => [T_4, (newState: T_4 | ((currentState: T_4) => T_4)) => void];
+    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    useRef: <T_5>(initialValue: T_5 | null) => import("./hooks").RefObject<T_5>;
+    useCallback: <T_6 extends (...args: unknown[]) => unknown>(callback: T_6, deps: readonly unknown[]) => T_6;
+    useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => void];
+    useDebugValue: (value: unknown, formatter?: ((value: unknown) => string) | undefined) => void;
+    use: <T_8>(promise: Promise<T_8>) => T_8;
+    startTransition: (callback: () => void) => void;
+    useTransition: () => [boolean, (callback: () => void) => void];
+    useDeferredValue: <T_9>(value: T_9) => T_9;
+    startViewTransition: (callback: () => void) => void;
+    useViewTransition: () => [boolean, (callback: () => void) => void];
+    useMemo: <T_10>(factory: () => T_10, deps: readonly unknown[]) => T_10;
+    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    Suspense: import("./base").FC<import("./types").PropsWithChildren<{
+        fallback: any;
+    }>>;
+};
+export default _default;
 export * from './types';

package/dist/types/middleware/body-limit/index.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type OnError = (c: Context) => Response | Promise<Response>;
+type BodyLimitOptions = {
+    maxSize: number;
+    onError?: OnError;
+};
+/**
+ * Body Limit Middleware
+ *
+ * @example
+ * ```ts
+ * app.post(
+ *  '/hello',
+ *  bodyLimit({
+ *    maxSize: 100 * 1024, // 100kb
+ *    onError: (c) => {
+ *      return c.text('overflow :(', 413)
+ *    }
+ *  }),
+ *  (c) => {
+ *    return c.text('pass :)')
+ *  }
+ * )
+ * ```
+ */
+export declare const bodyLimit: (options: BodyLimitOptions) => MiddlewareHandler;
+export {};

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

@@ -0,0 +1 @@
+export declare function getColorEnabled(): boolean;

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

@@ -0,0 +1,7 @@
+export interface Pool {
+    run<T>(fn: () => T): Promise<T>;
+}
+export declare const createPool: ({ concurrency, interval, }?: {
+    concurrency?: number | undefined;
+    interval?: number | undefined;
+}) => Pool;

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

@@ -10,7 +10,9 @@ export type CookieOptions = {
     signingSecret?: string;
     sameSite?: 'Strict' | 'Lax' | 'None';
     partitioned?: boolean;
+    prefix?: CookiePrefixOptions;
 };
+export type CookiePrefixOptions = 'host' | 'secure';
 export declare const parse: (cookie: string, name?: string) => Cookie;
 export declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
 export declare const serialize: (name: string, value: string, opt?: CookieOptions) => string;

package/dist/utils/color.js

@@ -0,0 +1,9 @@
+// src/utils/color.ts
+function getColorEnabled() {
+  const { process, Deno } = globalThis;
+  const isNoColor = typeof process !== "undefined" ? "NO_COLOR" in process?.env : typeof Deno?.noColor === "boolean" ? Deno.noColor : false;
+  return !isNoColor;
+}
+export {
+  getColorEnabled
+};

package/dist/utils/concurrent.js

@@ -0,0 +1,39 @@
+// src/utils/concurrent.ts
+var DEFAULT_CONCURRENCY = 1024;
+var createPool = ({
+  concurrency,
+  interval
+} = {}) => {
+  concurrency ||= DEFAULT_CONCURRENCY;
+  if (concurrency === Infinity) {
+    return {
+      run: async (fn) => fn()
+    };
+  }
+  const pool = /* @__PURE__ */ new Set();
+  const run = async (fn, promise, resolve) => {
+    if (pool.size >= concurrency) {
+      promise ||= new Promise((r) => resolve = r);
+      setTimeout(() => run(fn, promise, resolve));
+      return promise;
+    }
+    const marker = {};
+    pool.add(marker);
+    const result = await fn();
+    if (interval) {
+      setTimeout(() => pool.delete(marker), interval);
+    } else {
+      pool.delete(marker);
+    }
+    if (resolve) {
+      resolve(result);
+      return promise;
+    } else {
+      return result;
+    }
+  };
+  return { run };
+};
+export {
+  createPool
+};

package/dist/utils/cookie.js

@@ -66,16 +66,40 @@ var parseSigned = async (cookie, secret, name) => {
 };
 var _serialize = (name, value, opt = {}) => {
   let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
   if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 3456e4) {
+      throw new Error(
+        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
+      );
+    }
     cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
   }
-  if (opt.domain) {
+  if (opt.domain && opt.prefix !== "host") {
     cookie += `; Domain=${opt.domain}`;
   }
   if (opt.path) {
     cookie += `; Path=${opt.path}`;
   }
   if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 3456e7) {
+      throw new Error(
+        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
+      );
+    }
     cookie += `; Expires=${opt.expires.toUTCString()}`;
   }
   if (opt.httpOnly) {
@@ -88,6 +112,9 @@ var _serialize = (name, value, opt = {}) => {
     cookie += `; SameSite=${opt.sameSite}`;
   }
   if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
     cookie += "; Partitioned";
   }
   return cookie;

package/dist/utils/stream.js

@@ -1,7 +1,11 @@
 // src/utils/stream.ts
 var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
   constructor(writable, _readable) {
-    this.abortSubscribers = [];
     this.writable = writable;
     this.writer = writable.getWriter();
     this.encoder = new TextEncoder();

package/dist/utils/url.js

@@ -144,7 +144,7 @@ var _getQueryParam = (url, key, multiple) => {
     }
   }
   const results = {};
-  encoded ?? (encoded = /[%+]/.test(url));
+  encoded ??= /[%+]/.test(url);
   let keyIndex = url.indexOf("?", 8);
   while (keyIndex !== -1) {
     const nextKeyIndex = url.indexOf("&", keyIndex + 1);
@@ -179,7 +179,7 @@ var _getQueryParam = (url, key, multiple) => {
       ;
       results[name].push(value);
     } else {
-      results[name] ?? (results[name] = value);
+      results[name] ??= value;
     }
   }
   return key ? results[key] : results;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.0.10",
+  "version": "4.1.0",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -74,6 +74,11 @@
       "import": "./dist/middleware/bearer-auth/index.js",
       "require": "./dist/cjs/middleware/bearer-auth/index.js"
     },
+    "./body-limit": {
+      "types": "./dist/types/middleware/body-limit/index.d.ts",
+      "import": "./dist/middleware/body-limit/index.js",
+      "require": "./dist/cjs/middleware/body-limit/index.js"
+    },
     "./cache": {
       "types": "./dist/types/middleware/cache/index.d.ts",
       "import": "./dist/middleware/cache/index.js",
@@ -313,6 +318,11 @@
       "types": "./dist/types/helper/dev/index.d.ts",
       "import": "./dist/helper/dev/index.js",
       "require": "./dist/cjs/helper/dev/index.js"
+    },
+    "./ws": {
+      "types": "./dist/types/helper/websocket/index.d.ts",
+      "import": "./dist/helper/websocket/index.js",
+      "require": "./dist/cjs/helper/websocket/index.js"
     }
   },
   "typesVersions": {
@@ -338,6 +348,9 @@
       "bearer-auth": [
         "./dist/types/middleware/bearer-auth"
       ],
+      "body-limit": [
+        "./dist/types/middleware/body-limit"
+      ],
       "cache": [
         "./dist/types/middleware/cache"
       ],
@@ -475,6 +488,9 @@
       ],
       "dev": [
         "./dist/types/helper/dev"
+      ],
+      "ws": [
+        "./dist/types/helper/websocket"
       ]
     }
   },
@@ -508,7 +524,7 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20231121.0",
     "@hono/eslint-config": "^0.0.4",
-    "@hono/node-server": "^1.3.3",
+    "@hono/node-server": "^1.8.2",
     "@types/crypto-js": "^4.1.1",
     "@types/glob": "^8.0.0",
     "@types/jsdom": "^21.1.4",