DEPRECATED: prefer `sec-websocket-accept`

Returns `{:body ch}`, where `ch` is the request's underlying
asynchronous HTTP or WebSocket `AsyncChannel`.

Main options:
  :init       - (fn [ch])             for misc pre-handshake setup.
  :on-receive - (fn [ch message])     called for client WebSocket messages.
  :on-ping    - (fn [ch data])        called for client WebSocket pings.
  :on-close   - (fn [ch status-code]) called when AsyncChannel is closed.
  :on-open    - (fn [ch])             called when AsyncChannel is ready for `send!`, etc.

See `Channel` protocol for more info on handlers and `AsyncChannel`s.
See `org.httpkit.timer` ns for optional timeout utils.

---

Example - Async HTTP response:

  (def clients_ (atom #{}))
  (defn my-async-handler [ring-req]
    (as-channel ring-req
      {:on-open (fn [ch] (swap! clients_ conj ch))}))

  ;; Somewhere else in your code
  (doseq [ch @clients_]
    (swap! clients_ disj ch)
    (send! ch {:status 200 :headers {"Content-Type" "text/html"}
               :body "Your async response"}
      ;; false ; Uncomment to use chunk encoding for HTTP streaming
      ))

Example - WebSocket response:

  (defn my-chatroom-handler [ring-req]
    (if-not (:websocket? ring-req)
      {:status 200 :body "Welcome to the chatroom! JS client connecting..."}
      (as-channel ring-req
        {:on-receive (fn [ch message]     (println "on-receive:" message))
         :on-close   (fn [ch status-code] (println "on-close:"   status-code))
         :on-open    (fn [ch]             (println "on-open:"    ch))})))

Unified asynchronous channel interface for HTTP (streaming or long-polling)
and WebSocket.

Returns {:keys [n-cores type pool ...]} where `:pool` is a new
`java.util.concurrent.ExecutorService` for handling server requests.

When on JVM 21+, uses `newVirtualThreadPerTaskExecutor` by default.
Otherwise creates a standard `ThreadPoolExecutor` with default min and max
thread count auto-selected based on currently available processor count.

Starts a mostly[1] Ring-compatible HttpServer with options:

  :ip                 ; Which IP to bind (default: 0.0.0.0)
  :port               ; Which port to listen to for incoming requests

  :worker-pool        ; `java.util.concurrent.ExecutorService` or delay to use
                      ; for handling requests. Defaults to (:pool (new-worker {})).
                      ; See `new-worker` for details.

  :max-body           ; Max HTTP body size in bytes (default: 8MB)
  :max-ws             ; Max WebSocket message size in bytes (default: 4MB)
  :max-line           ; Max HTTP header line size in bytes (default: 8KB)

  :proxy-protocol     ; Proxy protocol e/o #{:disable :enable :optional}

  :server-header      ; The "Server" header, disabled if nil. Default: "http-kit".

  :error-logger       ; (fn [msg ex])  -> log errors
  :warn-logger        ; (fn [msg ex])  -> log warnings
  :event-logger       ; (fn [ev-name]) -> log events
  :event-names        ; Map of http-kit event names to loggable event names

  ;; These opts may be used for Unix Domain Socket (UDS) support, see README:
  :address-finder     ; (fn []) -> `java.net.SocketAddress` (ip/port ignored)
  :channel-factory    ; (fn [java.net.SocketAddress]) -> `java.nio.channels.SocketChannel`

If :legacy-return-value? is
  true  (default)     ; Returns a (fn stop-server [& {:keys [timeout] :or {timeout 100}}])
  false (recommended) ; Returns the `HttpServer` which can be used with `server-port`,
                      ; `server-status`, `server-stop!`, etc.

The server also supports the following JVM properties:

   `org.http-kit.memmap-file-threshold`
     Files above this size (in MB) are mapped into memory for efficiency when served.
     Memory mapping could result to file locking. Defaults to 20 (MB).

[1] Ref. http://http-kit.org/migration.html for differences.

Given an AsyncChannel and `sec-ws-accept` string, unconditionally
sends handshake to upgrade given AsyncChannel to a WebSocket.
See also `websocket-handshake-check`.

Returns true iff successfully upgraded a valid WebSocket request.

Signals given HttpServer to stop.

If     already stopping: returns nil.
If not already stopping: returns a Promise that will be delivered once
server thread actually completes.

Options:
  :timeout ; Max msecs to allow existing requests to complete before attempting
           ; interrupt (default 100).

Returns `sec-ws-accept` string iff given Ring request is a valid
WebSocket handshake.

DEPRECATED: this macro has potential race conditions, Ref. #318.
Prefer `as-channel` instead.