public:

using close_callback = std::function<void(close_info)>;

// Throws invalid_argument for an options object failing validate().

explicit session(options limits = {}, close_callback on_close = {});

~session();

session(session&&) noexcept;

session& operator=(session&&) noexcept;

session(const session&) = delete;

session& operator=(const session&) = delete;

// Copies the entire payload on accepted. All other dispositions leave

// queues unchanged. rejected distinguishes invalid/oversize arguments

// from temporary backpressure, which carries an ok status.

send_result try_send(message_kind kind, std::span<const std::byte> payload);

task<receive_result> receive();

// Capacity for at least an empty frame became available. Recheck

// try_send: this neither acknowledges delivery nor promises arbitrary

// message admission. Closing wakes the wait with connection_closed.

task<http::outcome> writable();

// Retain the handle through on_close; Close waits for a peer reply

// within the server ws_close budget, also bounded by any server drain.

http::outcome close(std::uint16_t code = 1000, std::string_view reason = {});

// Register once, before terminal closure. Constructor callbacks occupy

// the same registration slot. Empty callbacks are invalid arguments.

http::outcome on_close(close_callback callback);

private:

friend class httpserver::detail::websocket_driver;

explicit session(std::shared_ptr<detail::session_state> state) : state_(std::move(state)) { }

void cancel(http::outcome reason = {http::outcome_code::cancelled, "session cancelled"});

void transport_failed(http::outcome reason);

std::shared_ptr<detail::session_state> state_;