Summary

PR #4393 introduced MergeMiddlewareResponse<M_k> to capture middleware responses (e.g. c.json({ error }, 401) returned from a preceding handler) into the inferred RPC schema. The change was applied
to HandlerInterface (app.get/post/...) but OnHandlerInterface was not updated, so the same
route declared with app.on(method, path, ...) or app.on(method[], path, ...) silently dropped
middleware responses from the schema.

This is the same shape of asymmetry that #3852 and #4865 already fixed for narrower cases (R discard)
— OnHandlerInterface keeps drifting away from HandlerInterface whenever the handler-side overloads
gain new type parameters.

Affected overloads

18 overloads in total:

• app.on(method, path, handler x2..x10) — 9 overloads
• app.on(method[], path, handler x2..x10) — 9 overloads

The single-handler variants (x1) and the rest-array fallback overloads are unaffected because they
have no preceding middleware position to capture.

Reproduction

import { Hono } from 'hono'
import { hc } from 'hono/client'
import { createMiddleware } from 'hono/factory'

const auth = createMiddleware(async (c, next) => {
  if (!authorized) return c.json({ error: 'unauthorized' }, 401)
  await next()
})

// Works correctly (already covered by #4393)
const a = new Hono().get('/secret', auth, (c) => c.json({ ok: true }, 200))

// Bug: `output` collapses to `{ ok: true }` only, dropping the 401 response
const b = new Hono().on('GET', '/secret', auth, (c) => c.json({ ok: true }, 200))

const client = hc<typeof b>('/')
const res = await client.secret.$get()
if (res.status === 401) {
  // Before this PR: TypeScript narrows to `never`, so this branch is unreachable
  // After this PR:  `res.json()` resolves to `{ error: string }`
  const err = await res.json()
}

Switching app.on('GET', ...) ↔ app.get(...) flips the inference even though the routes are
semantically identical. The same gap exists for the method[] form.

Fix

For each of the 18 affected overloads, add M1..M(n-1) middleware type parameters mirroring
HandlerInterface, intersect them into the handler tuple positions before the final response handler,
and union MergeMiddlewareResponse<M_k> into the schema's response type.

The same shape is applied for handler counts 3..10 (with M1..M(n-1)) and for the methods: M[]
overloads.

Test plan

Added regression tests under the existing describe('RPC supports Middleware responses', ...) block in
src/types.test.ts, mirroring the corresponding app.get tests. Coverage:

• app.on('GET', '/test', ...) with 1, 2, 5, and 9 middlewares before the response handler
• app.on(['GET'], '/test', ...) with 1, 2, 5, and 9 middlewares before the response handler

Each test asserts that every middleware status code (400, 401, 403, ...) is reachable in the
inferred RPC client and that res.json() is narrowed correctly per status. These tests fail on main
(status union collapses to just 200, so every middleware-status branch becomes never) and pass
after this fix.

• bun run format:fix && bun run lint:fix
• bun run test (full type check + vitest, 3400 passed)
• Added regression tests for both single-method and method[] variants

Related history

• feat(types): passing middleware types #4393 (2025-10-15) — feat(types): passing middleware types
  Introduced MergeMiddlewareResponse<M_k> for HandlerInterface only.
• fix(types): missing response type on OnHandlerInterface #3852 (2025-01-25) — fix(types): missing response type on OnHandlerInterface
  Earlier R discard fix for OnHandlerInterface (different from this one).
• fix(types): infer response type from last handler in app.on 9-/10-handler overloads #4865 (2026-04-08) — fix(types): infer response type from last handler in app.on 9-/10-handler
  overloads
  Closer cousin: same kind of OnHandlerInterface drift, narrower scope.

This PR completes the alignment so that OnHandlerInterface mirrors HandlerInterface for both R
and M_k propagation. May also alleviate the open feedback in #3746.