http::outcome status;

std::span<const std::byte> data;

bool end_of_body = false;

data, // staged bytes copied into the destination

end, // authoritative end of body; trailers are final

empty, // nothing staged; the reader must park

failed, // framing/protocol failure; see body_source::failure()

public:

virtual ~body_source() = default;

// Moves at most into.size() staged bytes into `into` and returns

// the verdict plus the count copied. Returning data is THE

// consumption event: implementations release receive credit

// (backpressure relief) for exactly the bytes copied here — never

// for bytes merely staged. Zero-byte pulls returning data are

// forbidden; the reader skips them.

virtual body_pull_result pull(std::span<std::byte> into) = 0;

// Received trailers; final once a pull returned end.

virtual const http::fields& trailers() const noexcept = 0;

// Failure diagnostic; meaningful once a pull returned failed.

virtual const http::outcome& failure() const noexcept = 0;

// Parks `wait` until the FIRST of: bytes staged (data), end

// reached, failure raised, or the exchange's stop requested

// (cancelled). Completes at most once, posted to the waiter's

// executor (never inline on the completing thread). Precondition:

// at most one waiter parked per source.

virtual void park(body_wait& wait) = 0;

// Detaches a still-parked waiter (the waiter was destroyed without

// waking). After unpark, the source must forget the waiter.

virtual void unpark(body_wait& wait) = 0;

std::atomic<bool> delivered{false};

body_wake result = body_wake::cancelled;

std::coroutine_handle<> awaiting;

std::shared_ptr<frame_witness> witness; // null for foreign coroutines

executor* target = nullptr; // null resumes witness-guarded

bool claim() noexcept;

// Posts the resumption to the waiter's executor. Only when no

// executor is known does the resumption run inline, still guarded

// by the frame witness.

void resume_posted() noexcept;

public:

body_wait(body_source* source, stop_token cancel);

body_wait(const body_wait&) = delete;

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

body_wait(body_wait&&) = delete;

body_wait& operator=(body_wait&&) = delete;

body_wait& bind_frame(task_frame_base* frame) noexcept;

bool await_ready() const noexcept { return false; }

std::coroutine_handle<> await_suspend(std::coroutine_handle<> awaiting);

body_wake await_resume() const noexcept { return node_->result; }

// Completion entry for body_source implementations (any thread).

// Exactly-once via the claim; a losing later completion is a

// no-op. The posted job owns the node, so it stays safe across

// waiter destruction.

void complete(body_wake wake) noexcept;

// The exchange's disconnect token: the seam completes a parked

// wait as cancelled when it fires.

const stop_token& cancel_token() const noexcept { return cancel_; }

~body_wait();

private:

friend class http2_body_stream;

body_source* source_;

std::shared_ptr<wait_node> node_;

task_frame_base* frame_ = nullptr;

stop_token cancel_;

public:

// Bounded incremental read: resolves with at least one byte (and

// at most destination.size()) unless the body ends first. An empty

// destination fails invalid_argument without touching the engine.

task<body_read> read_some(std::span<std::byte> destination);

// The received trailers; final once a read returned end_of_body

// (or a collect succeeded). Empty when none were received.

const http::fields& trailers() const noexcept;

// Fully buffers the remaining body, at most `maximum` bytes. Fails

// limit_exceeded (diagnostic naming the cap) exactly when the body

// exceeds it; exactly-at-cap succeeds. On success the reader is at

// end of body and trailers() is final. A bodyless request (admitted

// with no engine source) collects to zero bytes successfully.

task<body_collect> collect(std::uint64_t maximum);

body_reader(body_reader&& other) noexcept = default;

body_reader& operator=(body_reader&& other) noexcept = default;

body_reader(const body_reader&) = delete;

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

private:

friend class exchange;

explicit body_reader(stop_token cancel) noexcept

: cancel_token_(std::move(cancel)) { }

// exchange::admit_body, after the engine accepted the admission. A

// null source is the bodyless-request shape: the engine accepted the

// admission but has no body to deliver (see bodyless()).

void activate(detail::body_source* source) noexcept;

// exchange::respond/upgrade, before committing: the exchange is

// terminal and the body is over.

void close() noexcept { closed_ = true; }

// exchange::disconnect, before the stop fan-out: stores the detail

// that reads issued after the disconnect report with their typed

// connection_closed failure.

void note_disconnect(const http::outcome& reason) noexcept {

disconnect_reason_ = reason;

}

// Shared entry gate of the read operations: fails typed and

// touches nothing when a pull may not start.

http::outcome enter(bool empty_destination) const;

// Sticky failure: the body is unusable after this point; later

// reads return the same outcome without touching the engine.

void fail_sticky(const http::outcome& reason) noexcept;

// An admission the engine accepted without a delivery source: the

// request carries no body (the engine's bodyless construction), so

// the body is empty and already complete.

bool bodyless() const noexcept { return admitted_ && source_ == nullptr; }

// Pull size for collect: never more than the remaining cap room,

// plus one probe byte that proves an over-limit body exactly. The

// probe may consume one byte of the tripping pull, which is

// discarded; the outcome stays exact.

static std::size_t collect_want(std::uint64_t room) noexcept {

return room < COLLECT_CHUNK_BYTES

? static_cast<std::size_t>(room) + 1

: COLLECT_CHUNK_BYTES;

}

static constexpr std::size_t COLLECT_CHUNK_BYTES = 512;

detail::body_source* source_ = nullptr;

stop_token cancel_token_;

http::outcome failure_;

http::outcome disconnect_reason_;

bool admitted_ = false;

bool pending_ = false;

bool at_end_ = false;

bool failed_ = false;

bool closed_ = false;