public:

stop_source() = default;

stop_source(stop_source&&) = default;

stop_source& operator=(stop_source&&) = default;

stop_source(const stop_source&) = delete;

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

// Requests stop. Returns true if this call won the race (first

// request); false afterwards. Idempotent and non-blocking; returns

// while the caller is inside a handler (DR-V3-008: handler-safe stop

// initiation returns immediately).

bool request_stop() noexcept { return source_.request_stop(); }

bool stop_requested() const noexcept { return source_.stop_requested(); }

bool stop_possible() const noexcept { return source_.stop_possible(); }

stop_token get_token() const noexcept;

private:

std::stop_source source_;

public:

stop_token() noexcept = default;

bool stop_requested() const noexcept { return token_.stop_requested(); }

bool stop_possible() const noexcept { return token_.stop_possible(); }

// Awaitable completing the awaiting task exactly once with the typed

// cancelled outcome. Completing a pre-cancelled token happens on the

// awaiting frame's own thread (symmetric transfer at registration

// time); completing after a later request_stop() is posted to the

// awaiting frame's executor — never run on the requesting thread.

class cancellation_awaiter final {

public:

explicit cancellation_awaiter(std::stop_token token) noexcept

: token_(std::move(token)) { }

cancellation_awaiter& bind_frame(detail::task_frame_base* frame) noexcept;

bool await_ready() const noexcept { return false; }

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

// Resumption only ever happens through a fired path.

void await_resume() const;

~cancellation_awaiter();

private:

struct fire {

cancellation_awaiter* self;

void operator()() const { self->on_stop(); }

};

bool claim() noexcept {

return !fired_.exchange(true, std::memory_order_acq_rel);

}

void on_stop() noexcept;

void post_resume() noexcept;

std::stop_token token_;

std::optional<std::stop_callback<fire>> callback_;

detail::task_frame_base* frame_ = nullptr;

std::coroutine_handle<> awaiting_;

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

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

// Single-resumer handoff between the registration re-check and the

// stop callback: exactly one exchange wins and resumes the waiter.

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

};

[[nodiscard]] cancellation_awaiter cancelled() const noexcept {

return cancellation_awaiter(token_);

}

private:

friend class stop_source;

explicit stop_token(std::stop_token token) noexcept

: token_(std::move(token)) { }

std::stop_token token_;