override def handleRequest(exchange: HttpServerExchange): Unit = {
 val out: F[Nothing, Unit] = for {
 out <- result(exchange).sandbox.leftMap(_.toEither)
 .redeemPure[TransportResponse](
 f => TransportResponse.Failure(handler.toRemote(exchange)(f)),
 v => TransportResponse.Success(v)
 )
 (code, headers, body) = convention.mapResponse(out)
 _ <- writeResponse(exchange, headers, code, body)
 _ <- F.sync(exchange.endExchange())
 } yield ()

 exchange.dispatch(new Runnable {
 override def run(): Unit = {
 BIORunner[F].unsafeRunAsyncAsEither(out)(errHandler.handle(RuntimeErrorHandler.Context.HttpRequest(exchange)))
 }
 })
 ()
}

private def writeResponse(exchange: HttpServerExchange, headers: Map[HttpString, String], code: Int, json: Json): F[Nothing, Unit] = {
  for {
    response <- F.sync(json.printWith(printer))
    _ <- undertowEventListener.onHttpResponse(response, code, headers.map(kv => (kv._1.toString, kv._2)))
    _ <- F.sync {
      exchange.setStatusCode(code)
      headers.foreach {
        case (h, v) =>
          exchange.getResponseHeaders.add(h, v)
      }
      exchange.getResponseSender.send(response)
    }
  } yield {
  }

}

public HttpServerExchange setStatusCode(final int statusCode) {
    if (statusCode < 0 || statusCode > 999) {
        throw new IllegalArgumentException("Invalid response code");
    }
    int oldVal = state;
    if (allAreSet(oldVal, FLAG_RESPONSE_SENT)) {
        throw UndertowMessages.MESSAGES.responseAlreadyStarted();
    }
...