hono 4.4.9 → 4.4.11

package/dist/cjs/client/client.js

@@ -152,11 +152,15 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
     return new URL(url);
   }
   if (method === "ws") {
-    const targetUrl = (0, import_utils.replaceUrlProtocol)(
+    const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
       opts.args[0] && opts.args[0].param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
       "ws"
     );
-    return new WebSocket(targetUrl);
+    const targetUrl = new URL(webSocketUrl);
+    for (const key in opts.args[0]?.query) {
+      targetUrl.searchParams.set(key, opts.args[0].query[key]);
+    }
+    return new WebSocket(targetUrl.toString());
   }
   const req = new ClientRequestImpl(url, method);
   if (method) {

package/dist/cjs/helper/streaming/sse.js

@@ -57,9 +57,16 @@ const run = async (stream, cb, onError) => {
     stream.close();
   }
 };
+const contextStash = /* @__PURE__ */ new WeakMap();
 const streamSSE = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream = new SSEStreamingApi(writable, readable);
+  c.req.raw.signal.addEventListener("abort", () => {
+    if (!stream.closed) {
+      stream.abort();
+    }
+  });
+  contextStash.set(stream.responseReadable, c);
   c.header("Transfer-Encoding", "chunked");
   c.header("Content-Type", "text/event-stream");
   c.header("Cache-Control", "no-cache");

package/dist/cjs/helper/streaming/stream.js

@@ -22,9 +22,16 @@ __export(stream_exports, {
 });
 module.exports = __toCommonJS(stream_exports);
 var import_stream = require("../../utils/stream");
+const contextStash = /* @__PURE__ */ new WeakMap();
 const stream = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream2 = new import_stream.StreamingApi(writable, readable);
+  c.req.raw.signal.addEventListener("abort", () => {
+    if (!stream2.closed) {
+      stream2.abort();
+    }
+  });
+  contextStash.set(stream2.responseReadable, c);
   (async () => {
     try {
       await cb(stream2);

package/dist/cjs/utils/stream.js

@@ -27,6 +27,8 @@ class StreamingApi {
   writable;
   abortSubscribers = [];
   responseReadable;
+  aborted = false;
+  closed = false;
   constructor(writable, _readable) {
     this.writable = writable;
     this.writer = writable.getWriter();
@@ -41,7 +43,7 @@ class StreamingApi {
         done ? controller.close() : controller.enqueue(value);
       },
       cancel: () => {
-        this.abortSubscribers.forEach((subscriber) => subscriber());
+        this.abort();
       }
     });
   }
@@ -67,6 +69,7 @@ class StreamingApi {
       await this.writer.close();
     } catch (e) {
     }
+    this.closed = true;
   }
   async pipe(body) {
     this.writer.releaseLock();
@@ -76,6 +79,12 @@ class StreamingApi {
   onAbort(listener) {
     this.abortSubscribers.push(listener);
   }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/validator/validator.js

@@ -45,33 +45,34 @@ const validator = (target, validationFunc) => {
         if (!contentType) {
           break;
         }
+        let formData;
         if (c.req.bodyCache.formData) {
-          value = await c.req.bodyCache.formData;
-          break;
+          formData = await c.req.bodyCache.formData;
+        } else {
+          try {
+            const arrayBuffer = await c.req.arrayBuffer();
+            formData = await (0, import_buffer.bufferToFormData)(arrayBuffer, contentType);
+            c.req.bodyCache.formData = formData;
+          } catch (e) {
+            let message = "Malformed FormData request.";
+            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+            throw new import_http_exception.HTTPException(400, { message });
+          }
         }
-        try {
-          const arrayBuffer = await c.req.arrayBuffer();
-          const formData = await (0, import_buffer.bufferToFormData)(arrayBuffer, contentType);
-          const form = {};
-          formData.forEach((value2, key) => {
-            if (key.endsWith("[]")) {
-              if (form[key] === void 0) {
-                form[key] = [value2];
-              } else if (Array.isArray(form[key])) {
-                ;
-                form[key].push(value2);
-              }
-            } else {
-              form[key] = value2;
+        const form = {};
+        formData.forEach((value2, key) => {
+          if (key.endsWith("[]")) {
+            if (form[key] === void 0) {
+              form[key] = [value2];
+            } else if (Array.isArray(form[key])) {
+              ;
+              form[key].push(value2);
             }
-          });
-          value = form;
-          c.req.bodyCache.formData = formData;
-        } catch (e) {
-          let message = "Malformed FormData request.";
-          message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-          throw new import_http_exception.HTTPException(400, { message });
-        }
+          } else {
+            form[key] = value2;
+          }
+        });
+        value = form;
         break;
       }
       case "query":

package/dist/client/client.js

@@ -136,11 +136,15 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
     return new URL(url);
   }
   if (method === "ws") {
-    const targetUrl = replaceUrlProtocol(
+    const webSocketUrl = replaceUrlProtocol(
       opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url,
       "ws"
     );
-    return new WebSocket(targetUrl);
+    const targetUrl = new URL(webSocketUrl);
+    for (const key in opts.args[0]?.query) {
+      targetUrl.searchParams.set(key, opts.args[0].query[key]);
+    }
+    return new WebSocket(targetUrl.toString());
   }
   const req = new ClientRequestImpl(url, method);
   if (method) {

package/dist/helper/streaming/sse.js

@@ -34,9 +34,16 @@ var run = async (stream, cb, onError) => {
     stream.close();
   }
 };
+var contextStash = /* @__PURE__ */ new WeakMap();
 var streamSSE = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream = new SSEStreamingApi(writable, readable);
+  c.req.raw.signal.addEventListener("abort", () => {
+    if (!stream.closed) {
+      stream.abort();
+    }
+  });
+  contextStash.set(stream.responseReadable, c);
   c.header("Transfer-Encoding", "chunked");
   c.header("Content-Type", "text/event-stream");
   c.header("Cache-Control", "no-cache");

package/dist/helper/streaming/stream.js

@@ -1,8 +1,15 @@
 // src/helper/streaming/stream.ts
 import { StreamingApi } from "../../utils/stream.js";
+var contextStash = /* @__PURE__ */ new WeakMap();
 var stream = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream2 = new StreamingApi(writable, readable);
+  c.req.raw.signal.addEventListener("abort", () => {
+    if (!stream2.closed) {
+      stream2.abort();
+    }
+  });
+  contextStash.set(stream2.responseReadable, c);
   (async () => {
     try {
       await cb(stream2);

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

@@ -79,7 +79,7 @@ type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T
 } ? S extends U ? O : never : never;
 export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
 export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-type PathToChain<Path extends string, E extends Schema, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
+type PathToChain<Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
     [K in P]: PathToChain<R, E, Original>;
 } : {
     [K in Path extends '' ? 'index' : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;

package/dist/types/types.d.ts

@@ -38,26 +38,19 @@ export interface HTTPResponseError extends Error {
 export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, P, I>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4>, H<E6, P, I5, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4>, H<E6, P, I5, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -66,14 +59,13 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, P, I5>,
         H<E7, P, I6, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
+        H<E6, MergedPath, I5, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -83,15 +75,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E7, P, I6>,
         H<E8, P, I7, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
+        H<E7, MergedPath, I6, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -102,16 +93,15 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E8, P, I7>,
         H<E9, P, I8, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
+        H<E8, MergedPath, I7, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -123,7 +113,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E9, P, I8>,
         H<E10, P, I9, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
@@ -131,9 +121,8 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
+        H<E9, MergedPath, I8, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -146,6 +135,17 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E10, P, I9>,
         H<E11, P, I10, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
+        H<E2, MergedPath, I>,
+        H<E3, MergedPath, I2>,
+        H<E4, MergedPath, I3>,
+        H<E5, MergedPath, I4>,
+        H<E6, MergedPath, I5>,
+        H<E7, MergedPath, I6>,
+        H<E8, MergedPath, I7>,
+        H<E9, MergedPath, I8>,
+        H<E10, MergedPath, I9, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,

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

@@ -8,6 +8,14 @@ export declare class StreamingApi {
     private writable;
     private abortSubscribers;
     responseReadable: ReadableStream;
+    /**
+     * Whether the stream has been aborted.
+     */
+    aborted: boolean;
+    /**
+     * Whether the stream has been closed normally.
+     */
+    closed: boolean;
     constructor(writable: WritableStream, _readable: ReadableStream);
     write(input: Uint8Array | string): Promise<StreamingApi>;
     writeln(input: string): Promise<StreamingApi>;
@@ -15,4 +23,9 @@ export declare class StreamingApi {
     close(): Promise<void>;
     pipe(body: ReadableStream): Promise<void>;
     onAbort(listener: () => void | Promise<void>): void;
+    /**
+     * Abort the stream.
+     * You can call this method when stream is aborted by external event.
+     */
+    abort(): void;
 }

package/dist/utils/stream.js

@@ -5,6 +5,8 @@ var StreamingApi = class {
   writable;
   abortSubscribers = [];
   responseReadable;
+  aborted = false;
+  closed = false;
   constructor(writable, _readable) {
     this.writable = writable;
     this.writer = writable.getWriter();
@@ -19,7 +21,7 @@ var StreamingApi = class {
         done ? controller.close() : controller.enqueue(value);
       },
       cancel: () => {
-        this.abortSubscribers.forEach((subscriber) => subscriber());
+        this.abort();
       }
     });
   }
@@ -45,6 +47,7 @@ var StreamingApi = class {
       await this.writer.close();
     } catch (e) {
     }
+    this.closed = true;
   }
   async pipe(body) {
     this.writer.releaseLock();
@@ -54,6 +57,12 @@ var StreamingApi = class {
   onAbort(listener) {
     this.abortSubscribers.push(listener);
   }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
 };
 export {
   StreamingApi

package/dist/validator/validator.js

@@ -23,33 +23,34 @@ var validator = (target, validationFunc) => {
         if (!contentType) {
           break;
         }
+        let formData;
         if (c.req.bodyCache.formData) {
-          value = await c.req.bodyCache.formData;
-          break;
+          formData = await c.req.bodyCache.formData;
+        } else {
+          try {
+            const arrayBuffer = await c.req.arrayBuffer();
+            formData = await bufferToFormData(arrayBuffer, contentType);
+            c.req.bodyCache.formData = formData;
+          } catch (e) {
+            let message = "Malformed FormData request.";
+            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+            throw new HTTPException(400, { message });
+          }
         }
-        try {
-          const arrayBuffer = await c.req.arrayBuffer();
-          const formData = await bufferToFormData(arrayBuffer, contentType);
-          const form = {};
-          formData.forEach((value2, key) => {
-            if (key.endsWith("[]")) {
-              if (form[key] === void 0) {
-                form[key] = [value2];
-              } else if (Array.isArray(form[key])) {
-                ;
-                form[key].push(value2);
-              }
-            } else {
-              form[key] = value2;
+        const form = {};
+        formData.forEach((value2, key) => {
+          if (key.endsWith("[]")) {
+            if (form[key] === void 0) {
+              form[key] = [value2];
+            } else if (Array.isArray(form[key])) {
+              ;
+              form[key].push(value2);
             }
-          });
-          value = form;
-          c.req.bodyCache.formData = formData;
-        } catch (e) {
-          let message = "Malformed FormData request.";
-          message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-          throw new HTTPException(400, { message });
-        }
+          } else {
+            form[key] = value2;
+          }
+        });
+        value = form;
         break;
       }
       case "query":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.4.9",
+  "version": "4.4.11",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -12,7 +12,7 @@
   "scripts": {
     "test": "tsc --noEmit && vitest --run && vitest -c .vitest.config/jsx-runtime-default.ts --run && vitest -c .vitest.config/jsx-runtime-dom.ts --run",
     "test:watch": "vitest --watch",
-    "test:deno": "deno test --allow-read --allow-env --allow-write -c runtime_tests/deno/deno.json runtime_tests/deno && deno test --no-lock -c runtime_tests/deno-jsx/deno.precompile.json runtime_tests/deno-jsx && deno test --no-lock -c runtime_tests/deno-jsx/deno.react-jsx.json runtime_tests/deno-jsx",
+    "test:deno": "deno test --allow-read --allow-env --allow-write --allow-net -c runtime_tests/deno/deno.json runtime_tests/deno && deno test --no-lock -c runtime_tests/deno-jsx/deno.precompile.json runtime_tests/deno-jsx && deno test --no-lock -c runtime_tests/deno-jsx/deno.react-jsx.json runtime_tests/deno-jsx",
     "test:bun": "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",