honojs
diff --git a/‎benchmarks/fetch/bench.mts‎
Lines changed: 41 additions & 12 deletions b/‎benchmarks/fetch/bench.mts‎
Lines changed: 41 additions & 12 deletions
diff --git a/‎jsr.json‎
Lines changed: 1 addition & 0 deletions b/‎jsr.json‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎package.json‎
Lines changed: 8 additions & 0 deletions b/‎package.json‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎src/client/types.test.ts‎
Lines changed: 1 addition & 0 deletions b/‎src/client/types.test.ts‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎src/client/types.ts‎
Lines changed: 1 addition & 1 deletion b/‎src/client/types.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/context.ts‎
Lines changed: 29 additions & 16 deletions b/‎src/context.ts‎
Lines changed: 29 additions & 16 deletions
diff --git a/‎src/hono-base.ts‎
Lines changed: 4 additions & 3 deletions b/‎src/hono-base.ts‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎src/hono.test.ts‎
Lines changed: 41 additions & 0 deletions b/‎src/hono.test.ts‎
Lines changed: 41 additions & 0 deletions
diff --git a/‎src/jsx/base.ts‎
Lines changed: 41 additions & 18 deletions b/‎src/jsx/base.ts‎
Lines changed: 41 additions & 18 deletions
@@ -11,13 +11,14 @@
 //   HONO_SRC    ... path to the hono `src` directory to benchmark (default: ../../src)
 //   HONO_LABEL  ... label used in the output (default: hono)
 //   HONO_JSON=1 ... suppress mitata output and print a single JSON line instead
+//   HONO_CASE   ... run only cases whose name starts with this prefix (e.g. "ping")
 //
 // Runs on both Bun and Node.
 import './ts-resolve.mjs'
-import { run, bench } from 'mitata'
-import { pathToFileURL } from 'node:url'
+import { run, bench, measure } from 'mitata'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
-const src = process.env.HONO_SRC ?? new URL('../../src', import.meta.url).pathname
+const src = process.env.HONO_SRC ?? fileURLToPath(new URL('../../src', import.meta.url))
 const label = process.env.HONO_LABEL ?? 'hono'
 const asJson = process.env.HONO_JSON === '1'
 
@@ -37,20 +38,30 @@ const makeApp = async (src: string): Promise<any> => {
       c.header('x-powered-by', 'benchmark')
       return c.text(`${id} ${name}`)
     })
+    .get('/user', (c: any) => c.json({ id: 123, name: 'Alice', roles: ['admin', 'editor'] }))
+    .use('/mw/*', async (_c: any, next: any) => {
+      await next()
+    })
+    .get('/mw/hello', (c: any) => c.text('mw'))
   return app
 }
 
 const app = await makeApp(src)
 
 const ping = new Request('http://localhost/')
 const query = new Request('http://localhost/id/1?name=bun')
+const user = new Request('http://localhost/user')
+const mw = new Request('http://localhost/mw/hello')
 
 let sink: unknown
 
- 
-const cases: [string, (app: any) => Promise<unknown>][] = [
+const caseFilter = process.env.HONO_CASE
+
+const allCases: [string, (app: any) => Promise<unknown>][] = [
   ['ping GET /', (app) => app.fetch(ping)],
   ['query GET /id/1?name=bun', (app) => app.fetch(query)],
+  ['json GET /user', (app) => app.fetch(user)],
+  ['middleware GET /mw/hello', (app) => app.fetch(mw)],
   [
     'body POST /json',
     (app) =>
@@ -64,21 +75,39 @@ const cases: [string, (app: any) => Promise<unknown>][] = [
   ],
 ]
 
+const cases = caseFilter ? allCases.filter(([name]) => name.startsWith(caseFilter)) : allCases
+if (cases.length === 0) {
+  throw new Error(`no cases match HONO_CASE=${caseFilter}`)
+}
+
+// Warm up before registering benches: the first fetch builds the router
+// lazily (>500µs), which makes mitata skip batching for the first bench.
+for (const [, fn] of allCases) {
+  sink = await fn(app)
+}
+
 for (const [name, fn] of cases) {
   bench(name, async () => {
     sink = await fn(app)
   })
 }
 
 if (asJson) {
-  const { benchmarks } = await run({ format: 'quiet' })
+  // Force batching on: without it, each iteration is timed individually at
+  // timer granularity (~41ns on Apple Silicon), which is too coarse here.
   const results: Record<string, { avg: number; min: number; p75: number }> = {}
-  for (const b of benchmarks) {
-    const { stats, error } = b.runs[0]
-    if (error || !stats) {
-      throw error ?? new Error(`no stats for ${b.alias}`)
-    }
-    results[b.alias] = { avg: stats.avg, min: stats.min, p75: stats.p75 }
+  for (const [name, fn] of cases) {
+    const stats = await measure(
+      async () => {
+        sink = await fn(app)
+      },
+      {
+        warmup_threshold: Number.MAX_SAFE_INTEGER,
+        batch_threshold: Number.MAX_SAFE_INTEGER,
+      }
+    )
+    // p50 rather than avg: insensitive to the slow JIT tier-up windows
+    results[name] = { avg: stats.p50, min: stats.min, p75: stats.p75 }
   }
   console.log(JSON.stringify({ label, cases: results }))
   console.error(typeof sink)
 
@@ -45,6 +45,7 @@
     "./timeout": "./src/middleware/timeout/index.ts",
     "./timing": "./src/middleware/timing/timing.ts",
     "./logger": "./src/middleware/logger/index.ts",
+    "./method-not-allowed": "./src/middleware/method-not-allowed/index.ts",
     "./method-override": "./src/middleware/method-override/index.ts",
     "./powered-by": "./src/middleware/powered-by/index.ts",
     "./pretty-json": "./src/middleware/pretty-json/index.ts",
 
@@ -231,6 +231,11 @@
       "import": "./dist/middleware/logger/index.js",
       "require": "./dist/cjs/middleware/logger/index.js"
     },
+    "./method-not-allowed": {
+      "types": "./dist/types/middleware/method-not-allowed/index.d.ts",
+      "import": "./dist/middleware/method-not-allowed/index.js",
+      "require": "./dist/cjs/middleware/method-not-allowed/index.js"
+    },
     "./method-override": {
       "types": "./dist/types/middleware/method-override/index.d.ts",
       "import": "./dist/middleware/method-override/index.js",
@@ -528,6 +533,9 @@
       "logger": [
         "./dist/types/middleware/logger"
       ],
+      "method-not-allowed": [
+        "./dist/types/middleware/method-not-allowed"
+      ],
       "method-override": [
         "./dist/types/middleware/method-override"
       ],
 
@@ -117,6 +117,7 @@ describe('app.all()', () => {
     expectTypeOf(client['all-route']).toHaveProperty('$delete')
     expectTypeOf(client['all-route']).toHaveProperty('$options')
     expectTypeOf(client['all-route']).toHaveProperty('$patch')
+    expectTypeOf(client['all-route']).toHaveProperty('$query')
   })
 
   it('should have correct return type for expanded methods', async () => {
 
@@ -12,7 +12,7 @@ type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`
 
 /**
  * Type representing all standard HTTP methods prefixed with '$'
- * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch' | '$query'
  */
 type StandardMethods = `$${(typeof METHODS)[number]}`
 
 
@@ -606,14 +606,12 @@ export class Context<
     arg?: StatusCode | ResponseOrInit,
     headers?: HeaderRecord
   ): Response {
-    const responseHeaders = this.#res
-      ? new Headers(this.#res.headers)
-      : (this.#preparedHeaders ?? new Headers())
-
-    if (typeof arg === 'object' && 'headers' in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers)
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === 'set-cookie') {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders
+
+    if (typeof arg === 'object' && arg.headers) {
+      responseHeaders ??= new Headers()
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === 'set-cookie') {
           responseHeaders.append(key, value)
         } else {
           responseHeaders.set(key, value)
@@ -622,20 +620,35 @@ export class Context<
     }
 
     if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === 'string') {
-          responseHeaders.set(k, v)
-        } else {
-          responseHeaders.delete(k)
-          for (const v2 of v) {
-            responseHeaders.append(k, v2)
+      if (!responseHeaders) {
+        let count = 0
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k as keyof HeaderRecord] !== 'string') {
+            responseHeaders = new Headers()
+            break
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k as keyof HeaderRecord]
+          if (typeof v === 'string') {
+            responseHeaders.set(k, v)
+          } else {
+            responseHeaders.delete(k)
+            for (const v2 of v) {
+              responseHeaders.append(k, v2)
+            }
           }
         }
       }
     }
 
     const status = typeof arg === 'number' ? arg : (arg?.status ?? this.#status)
-    return createResponseInstance(data, { status, headers: responseHeaders })
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? (headers as Record<string, string> | undefined),
+    })
   }
 
   newResponse: NewResponse = (...args) => this.#newResponse(...(args as Parameters<NewResponse>))
 
@@ -107,6 +107,7 @@ class Hono<
   delete!: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>
   options!: HandlerInterface<E, 'options', S, BasePath, CurrentPath>
   patch!: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>
+  query!: HandlerInterface<E, 'query', S, BasePath, CurrentPath>
   all!: HandlerInterface<E, 'all', S, BasePath, CurrentPath>
   on: OnHandlerInterface<E, S, BasePath>
   use: MiddlewareHandlerInterface<E, S, BasePath>
@@ -471,14 +472,14 @@ class Hono<
    * @see {@link https://hono.dev/docs/api/hono#fetch}
    *
    * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
    * @returns {Response | Promise<Response>} response of request
    *
    */
   fetch: (
     request: Request,
-    Env?: E['Bindings'] | {},
+    env?: E['Bindings'] | {},
     executionCtx?: ExecutionContext
   ) => Response | Promise<Response> = (request, ...rest) => {
     return this.#dispatch(request, rest[1], rest[0], request.method)
 
@@ -2079,6 +2079,47 @@ describe('Multiple methods with `app.on`', () => {
   })
 })
 
+describe('Using QUERY with `app.query` and `app.on`', () => {
+  it('Should handle QUERY method with app.query()', async () => {
+    const app = new Hono()
+
+    app.query('/query', (c) => c.text('Accepted', 202))
+
+    const req = new Request('http://localhost/query', {
+      method: 'QUERY',
+    })
+    const res = await app.request(req)
+    expect(res.status).toBe(202)
+    expect(await res.text()).toBe('Accepted')
+  })
+
+  it('Should handle QUERY method with RegExpRouter', async () => {
+    const app = new Hono({ router: new RegExpRouter() })
+
+    app.on('QUERY', '/query', (c) => c.text('Accepted', 202))
+
+    const req = new Request('http://localhost/query', {
+      method: 'QUERY',
+    })
+    const res = await app.request(req)
+    expect(res.status).toBe(202)
+    expect(await res.text()).toBe('Accepted')
+  })
+
+  it('Should handle QUERY method with TrieRouter', async () => {
+    const app = new Hono({ router: new TrieRouter() })
+
+    app.on('QUERY', '/query', (c) => c.text('Accepted', 202))
+
+    const req = new Request('http://localhost/query', {
+      method: 'QUERY',
+    })
+    const res = await app.request(req)
+    expect(res.status).toBe(202)
+    expect(await res.text()).toBe('Accepted')
+  })
+})
+
 describe('Multiple paths with one handler', () => {
   const app = new Hono()
 
 
@@ -25,8 +25,13 @@ import {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Props = Record<string, any>
+type FunctionComponentResult =
+  | HtmlEscapedString
+  | Child[]
+  | Promise<HtmlEscapedString | Child[]>
+  | null
 export type FC<P = Props> = {
-  (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null
+  (props: P): FunctionComponentResult
   defaultProps?: Partial<P> | undefined
   displayName?: string | undefined
 }
@@ -35,6 +40,7 @@ export type DOMAttributes = HonoJSX.HTMLAttributes
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace JSX {
   export type Element = HtmlEscapedString | Promise<HtmlEscapedString>
+  export type ElementType = string | ((props: never) => FunctionComponentResult)
   export interface ElementChildrenAttribute {
     children: Child
   }
@@ -105,6 +111,27 @@ export const booleanAttributes = [
   'selected',
 ]
 
+type SuspendedContext = <T>(callback: () => T) => T
+
+const resolveFunctionComponentResult = (
+  result: Promise<string | JSXNode | Child[]>,
+  suspendedContext?: SuspendedContext
+): Promise<string> =>
+  result.then((resolved) => {
+    if (!Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+      return resolved
+    }
+    const children = Array.isArray(resolved) ? resolved : [resolved]
+    const render = () => {
+      const buffer: StringBufferWithCallbacks = [''] as StringBufferWithCallbacks
+      childrenToStringToBuffer(children, buffer)
+      return buffer.length === 1
+        ? raw(buffer[0], buffer.callbacks)
+        : stringBufferToString(buffer, buffer.callbacks)
+    }
+    return suspendedContext ? suspendedContext(render) : runWithRenderContext(render)
+  })
+
 const childrenToStringToBuffer = (children: Child[], buffer: StringBufferWithCallbacks): void => {
   for (let i = 0, len = children.length; i < len; i++) {
     const child = children[i]
@@ -114,11 +141,15 @@ const childrenToStringToBuffer = (children: Child[], buffer: StringBufferWithCal
       continue
     } else if (child instanceof JSXNode) {
       child.toStringToBuffer(buffer)
-    } else if (
-      typeof child === 'number' ||
-      (child as unknown as { isEscaped: boolean }).isEscaped
-    ) {
+    } else if (typeof child === 'number') {
       ;(buffer[0] as string) += child
+    } else if ((child as unknown as HtmlEscaped).isEscaped) {
+      ;(buffer[0] as string) += child
+      const callbacks = (child as unknown as HtmlEscapedString).callbacks
+      if (callbacks) {
+        buffer.callbacks ||= []
+        buffer.callbacks.push(...callbacks)
+      }
     } else if (child instanceof Promise) {
       buffer.unshift('', child)
     } else {
@@ -143,7 +174,6 @@ export class JSXNode implements HtmlEscaped {
   key?: string
   children: Child[]
   isEscaped: true = true as const
-  suspendedContext?: <T>(callback: () => T) => T
   constructor(tag: string | Function, props: Props, children: Child[]) {
     if (typeof tag !== 'function' && !isValidTagName(tag)) {
       throw new Error(`Invalid JSX tag name: ${tag}`)
@@ -173,7 +203,7 @@ export class JSXNode implements HtmlEscaped {
           : buffer[0]
         : stringBufferToString(buffer, buffer.callbacks)
     }
-    return this.suspendedContext ? this.suspendedContext(render) : runWithRenderContext(render)
+    return runWithRenderContext(render)
   }
 
   toStringToBuffer(buffer: StringBufferWithCallbacks): void {
@@ -267,22 +297,15 @@ class JSXFunctionNode extends JSXNode {
       return
     } else if (res instanceof Promise) {
       if (globalContexts.length === 0) {
-        buffer.unshift('', res)
+        buffer.unshift('', resolveFunctionComponentResult(res))
       } else {
         // save the current context state for resuming the suspended subtree
-        const suspendedContext = captureRenderContext()
-        buffer.unshift(
-          '',
-          res.then((childRes) => {
-            if (childRes instanceof JSXNode) {
-              childRes.suspendedContext = suspendedContext
-            }
-            return childRes
-          })
-        )
+        buffer.unshift('', resolveFunctionComponentResult(res, captureRenderContext()))
       }
     } else if (res instanceof JSXNode) {
       res.toStringToBuffer(buffer)
+    } else if (Array.isArray(res)) {
+      childrenToStringToBuffer(res, buffer)
     } else if (typeof res === 'number' || (res as HtmlEscaped).isEscaped) {
       buffer[0] += res
       if (res.callbacks) {