client.hpp

Go to the documentation of this file.

// nros-cpp: Action client class
// Freestanding C++ — no exceptions, no STL required

 
#ifndef NROS_RCLCPP_ACTION_CLIENT_HPP
#define NROS_RCLCPP_ACTION_CLIENT_HPP
 
#include <cstdint>
#include <cstddef>
#include <string.h>
 
#include "rclcpp/detail/config.hpp"
#include "rclcpp/detail/entity_name.hpp" // phase-444 — the one entity-name copy
#include "rclcpp/logging.hpp" // phase-417 stage 3 — NROS_RCLCPP_REFUSE_* + rclcpp::detail::refuse
#include "rclcpp/owned.hpp"   // issue 2015 — `Client<A>::SharedPtr`
#include "rclcpp/result.hpp"
#include "rclcpp/size_bound.hpp" // rclcpp::rx_buffer_capacity<M> — the receive-buffer size
#include "rclcpp/future.hpp"
#include "rclcpp/stream.hpp"
#include "rclcpp/time.hpp" // issue 2027 — `async_cancel_goals_before(const rclcpp::Time&)`
// Issue 0796 — `CancelReturnCode` (the `action_msgs/srv/CancelGoal` RPC status
// `cancel_goal` resolves to) is declared beside its per-goal sibling
// `CancelResponse` in action_server.hpp, which is also where
// polling_action_server.hpp reaches for them.
#include "rclcpp_action/server.hpp"
#include "rclcpp_action/detail/upstream.hpp" // issue 2015 — hosted goal-handle plumbing
 
// Phase 118.D: FFI declarations sourced from cbindgen-generated
// `nros_cpp_ffi.h`. cbindgen renders Rust `*const [u8; 16]` /
// `*mut [u8; 16]` parameters as C++ pointer-to-array
// (`const uint8_t (*goal_id)[16]`); member-function bodies below
// take `goal_id` as a 16-byte array (decays to `uint8_t*`) and
// `reinterpret_cast` at the call site to bridge the two ABI
// equivalent shapes.
#include "rclcpp/detail/nros_cpp_ffi.h"
 
extern "C" {
typedef void (*nros_cpp_action_client_goal_response_callback_t)(bool accepted,
                                                                const uint8_t goal_id[16],
                                                                void* ctx);
typedef void (*nros_cpp_action_client_feedback_callback_t)(const uint8_t goal_id[16],
                                                           const uint8_t* data, size_t len,
                                                           void* ctx);
typedef void (*nros_cpp_action_client_result_callback_t)(const uint8_t goal_id[16], int32_t status,
                                                         const uint8_t* data, size_t len,
                                                         void* ctx);
 
nros_cpp_ret_t nros_cpp_action_client_set_callbacks(
    void* handle, nros_cpp_action_client_goal_response_callback_t goal_response,
    nros_cpp_action_client_feedback_callback_t feedback,
    nros_cpp_action_client_result_callback_t result, void* context);

typedef void (*nros_cpp_action_client_cancel_reply_callback_t)(const uint8_t goal_id[16],
                                                               int64_t seq, const uint8_t* reply,
                                                               size_t reply_len, void* ctx);
 
nros_cpp_ret_t
nros_cpp_action_client_set_cancel_reply_callback(void* handle,
                                                 nros_cpp_action_client_cancel_reply_callback_t cb);
} // extern "C"

namespace rclcpp {
class Node;
}
 
// ============================================================================
// `rclcpp_action::Client<A>` -- DEFINED here (RFC-0089: rclcpp_action:: is the home)
// ============================================================================
//
// phase-428: the definition moved from `nros::ActionClient<A>` to
// `rclcpp_action::Client<A>` (the `nros::` alias went in phase-483 W1). A RENAME
// as well as a move -- upstream's namespace already says "action", so the type
// is `Client`, not `ActionClient`. Note the two `Client`s do not collide:
// `rclcpp::Client<S>` is the SERVICE client, in a different namespace.
namespace rclcpp_action {

enum class ResultCode : int8_t {
    UNKNOWN = 0,
    SUCCEEDED = 4,
    CANCELED = 5,
    ABORTED = 6,
};

static const size_t MAX_CANCEL_INFOS = 16;

static const size_t CANCEL_STASH_CAP = 4;
 
template <typename A> class Client;

template <typename A> class ClientGoalHandle {
  public:
    using Feedback = typename A::Feedback;
    using Result = typename A::Result;
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
    using SharedPtr = ::std::shared_ptr<ClientGoalHandle>;
    using ConstSharedPtr = ::std::shared_ptr<const ClientGoalHandle>;
    struct WrappedResult {
        GoalUUID goal_id;
        ResultCode code;
        ::std::shared_ptr<Result> result;
    };
    using GoalResponseCallback = ::std::function<void(SharedPtr)>;
    using FeedbackCallback =
        ::std::function<void(SharedPtr, const ::std::shared_ptr<const Feedback>)>;
    using ResultCallback = ::std::function<void(const WrappedResult&)>;
#else
    using SharedPtr = detail::Refused<ClientGoalHandle>;
    using ConstSharedPtr = detail::Refused<ClientGoalHandle>;
    using WrappedResult = detail::Refused<ClientGoalHandle>;
#endif
 
    explicit ClientGoalHandle(const GoalUUID& id)
        : goal_id_(id), status_(static_cast<int8_t>(GoalStatus::Accepted)), feedback_aware_(false),
          result_aware_(false) {}
    ClientGoalHandle(const ClientGoalHandle&) = delete;
    ClientGoalHandle& operator=(const ClientGoalHandle&) = delete;

    const GoalUUID& get_goal_id() const { return goal_id_; }
    int8_t get_status() const { return status_; }
    bool is_feedback_aware() const { return feedback_aware_; }
    bool is_result_aware() const { return result_aware_; }
 
  private:
    friend class Client<A>;
 
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
    struct ResultState {
        ::std::promise<WrappedResult> promise;
        ::std::shared_future<WrappedResult> future;
        bool done = false;
    };
    ResultState* result_state() {
        ResultState* st = result_.template as<ResultState>();
        if (st == nullptr) {
            st = new ResultState();
            st->future = st->promise.get_future().share();
            result_.reset(st, [](void* p) { delete static_cast<ResultState*>(p); });
        }
        return st;
    }
    void set_result(const WrappedResult& wrapped) {
        ResultState* st = result_.template as<ResultState>();
        if (st != nullptr && !st->done) {
            st->done = true;
            st->promise.set_value(wrapped);
        }
    }
    bool result_done() const {
        ResultState* st = result_.template as<ResultState>();
        return st != nullptr && st->done;
    }
#endif
 
    GoalUUID goal_id_;
    int8_t status_;
    bool feedback_aware_;
    bool result_aware_;
    detail::HostedBox result_;
};
 
#if defined(NROS_CPP_HAS_SHARED_PTR) // hosted-family: action-interop
namespace detail {
struct CancelGoalInfo {
    struct {
        uint8_t uuid[16];
    } goal_id;
    struct {
        int32_t sec;
        uint32_t nanosec;
    } stamp;
};
struct CancelResponse {
    static constexpr int8_t ERROR_NONE = 0;
    static constexpr int8_t ERROR_REJECTED = 1;
    static constexpr int8_t ERROR_UNKNOWN_GOAL_ID = 2;
    static constexpr int8_t ERROR_GOAL_TERMINATED = 3;
    using SharedPtr = ::std::shared_ptr<CancelResponse>;
    int8_t return_code = ERROR_NONE;
    ::std::vector<CancelGoalInfo> goals_canceling;
};
} // namespace detail
#endif

template <typename A> class Client {
  public:
    using GoalType = typename A::Goal;
    using ResultType = typename A::Result;
    using FeedbackType = typename A::Feedback;

    using SharedPtr = ::rclcpp::Owned<Client>;
    using GoalHandle = ::rclcpp_action::ClientGoalHandle<A>;
    using WrappedResult = typename GoalHandle::WrappedResult;
#if defined(NROS_CPP_HAS_SHARED_PTR) // hosted-family: action-interop
    using CancelResponse = detail::CancelResponse;
    using CancelCallback = ::std::function<void(typename CancelResponse::SharedPtr)>;
    using ResultCallback = typename GoalHandle::ResultCallback;
#else
    using CancelResponse = detail::Refused<Client>;
#endif
 
  private:
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
    using FeedbackPtr = ::std::shared_ptr<const FeedbackType>;
#else
    using FeedbackPtr = detail::Refused<FeedbackType>;
#endif
 
  public:
    struct GoalAccept {
        uint8_t goal_id[16];
        bool accepted;
 
        // Receive-buffer size for `Future<GoalAccept>`; the payload is 17 bytes
        // (16-byte goal_id + 1 accepted byte), rounded up.
        static const size_t SERIALIZED_SIZE_MAX = 32;
 
        // Issue 0329 — the 17-byte wire layout is owned Rust-side
        // (`nros_cpp_action_goal_accept_decode`, beside its producer); the header
        // no longer hand-decodes it, so the two cannot drift.
        static int ffi_deserialize(const uint8_t* data, size_t len, GoalAccept* out) {
            if (!out) return -1;
            return nros_cpp_action_goal_accept_decode(data, len, &out->goal_id, &out->accepted) ==
                           NROS_CPP_RET_OK
                       ? 0
                       : -1;
        }
    };

    ::rclcpp::Result wait_for_action_server(uint32_t timeout_ms) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
        return ::rclcpp::Result(
            nros_cpp_action_client_wait_for_action_server(storage_, timeout_ms));
    }

    template <typename T = void>::rclcpp::Result wait_for_action_server() {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_UNBOUNDED_WAIT);
        return ::rclcpp::Result(::rclcpp::ErrorCode::Unsupported);
    }
 
#ifdef NROS_CPP_HAS_STD_CHRONO // hosted-family: chrono-interop
    template <typename Rep, typename Period>
    ::rclcpp::Result wait_for_action_server(::std::chrono::duration<Rep, Period> timeout) {
        const int64_t ms = ::rclcpp::detail::chrono_wait_budget_ms(timeout);
        if (ms < 0) {
            NROS_RCLCPP_SAY_REFUSED(NROS_RCLCPP_REFUSE_UNBOUNDED_WAIT_RUNTIME);
            return ::rclcpp::Result(::rclcpp::ErrorCode::Unsupported);
        }
        return wait_for_action_server(static_cast<uint32_t>(ms));
    }
#endif // NROS_CPP_HAS_STD_CHRONO

    bool action_server_is_ready() const {
        if (!initialized_) return false;
        return nros_cpp_action_client_action_server_is_ready(
            const_cast<void*>(static_cast<const void*>(storage_)));
    }

    const char* get_action_name() const { return initialized_ ? action_name_ : ""; }

    ::rclcpp::Result send_goal(const GoalType& goal, uint8_t goal_id[16]) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
 
        uint8_t buf[::rclcpp::detail::buffer_bounds<GoalType>::tx];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return ::rclcpp::Result(::rclcpp::ErrorCode::Error);
        }
        return ::rclcpp::Result(nros_cpp_action_client_send_goal(
            storage_, buf, len, reinterpret_cast<uint8_t(*)[16]>(goal_id)));
    }

    ::rclcpp::Result send_goal(const GoalType& goal, ::rclcpp_action::GoalUUID& goal_id) {
        return send_goal(goal, goal_id.data());
    }

    ::rclcpp::Result get_result(const uint8_t goal_id[16], ResultType& result) {
        return get_result_sized<::rclcpp::rx_buffer_capacity<ResultType>::value>(goal_id, result);
    }

    ::rclcpp::Result get_result(const ::rclcpp_action::GoalUUID& goal_id, ResultType& result) {
        return get_result_sized<::rclcpp::rx_buffer_capacity<ResultType>::value>(goal_id.data(),
                                                                                 result);
    }

    template <size_t Cap>
    ::rclcpp::Result get_result_sized(const uint8_t goal_id[16], ResultType& result) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
 
        uint8_t buf[Cap];
        size_t len = 0;
        nros_cpp_ret_t ret = nros_cpp_action_client_get_result(
            storage_, executor_, reinterpret_cast<const uint8_t(*)[16]>(goal_id), buf, sizeof(buf),
            &len);
        if (ret != 0) return ::rclcpp::Result(ret);
 
        if (ResultType::ffi_deserialize(buf, len, &result) != 0) {
            return ::rclcpp::Result(::rclcpp::ErrorCode::Error);
        }
        return ::rclcpp::Result::success();
    }
 
    // =================================================================
    // Future-based API — non-blocking, polled via Future<T>
    // =================================================================


    ::rclcpp::Future<GoalAccept> send_goal_future(const GoalType& goal) {
        if (!initialized_) return ::rclcpp::Future<GoalAccept>();
 
        uint8_t buf[::rclcpp::detail::buffer_bounds<GoalType>::tx];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return ::rclcpp::Future<GoalAccept>();
        }
 
        uint8_t goal_id[16];
        nros_cpp_ret_t ret = nros_cpp_action_client_send_goal_async(
            storage_, buf, len, reinterpret_cast<uint8_t(*)[16]>(goal_id));
        if (ret != 0) return ::rclcpp::Future<GoalAccept>();
 
        // Issue 2011 -- keyed by THIS goal on this client's acceptance list:
        // the acceptance reaches it whether the executor dispatched it during
        // `spin_once` (through `on_goal_response`) or the future's own poll
        // took it (`nros_cpp_action_client_poll`, same callbacks).
        return ::rclcpp::Future<GoalAccept>(storage_, &nros_cpp_action_client_poll, goal_id,
                                            &accepts_,
                                            executor_ // driven by `Future::wait_for` (issue 1996)
        );
    }

    /// Keyed by `goal_id` (issue 2011): the future receives that goal's result
    /// and no other, whichever client or future polls first. A result for a
    /// goal no future waits on -- including one whose future was cancelled or
    /// destroyed first -- is dropped (the client's result callback still sees
    /// it). Several futures for one goal each receive its result, one reply
    /// apiece.
    ///
    /// @param goal_id  16-byte goal UUID from send_goal() or GoalAccept.
    /// @return Future that resolves to ResultType. Returns a consumed
    ///         (empty) future on send failure, including a full table (at most
    ///         `MAX_CONCURRENT_GOALS` get_result requests pending per client).
    ::rclcpp::Future<ResultType> get_result_future(const uint8_t goal_id[16]) {
        return get_result_future_sized<::rclcpp::rx_buffer_capacity<ResultType>::value>(goal_id);
    }

    ::rclcpp::Future<ResultType> get_result_future(const ::rclcpp_action::GoalUUID& goal_id) {
        return get_result_future_sized<::rclcpp::rx_buffer_capacity<ResultType>::value>(
            goal_id.data());
    }

    template <size_t Cap>
    ::rclcpp::Future<ResultType, Cap> get_result_future_sized(const uint8_t goal_id[16]) {
        using Fut = ::rclcpp::Future<ResultType, Cap>;
        if (!initialized_) return Fut();
 
        nros_cpp_ret_t ret = nros_cpp_action_client_get_result_async(
            storage_, reinterpret_cast<const uint8_t(*)[16]>(goal_id));
        if (ret != 0) return Fut();
 
        // Issue 2011 -- keyed by THIS goal on this client's result list; see
        // `send_goal_future`.
        return Fut(storage_, &nros_cpp_action_client_poll, goal_id, &results_,
                   executor_ // driven by `Future::wait_for` (issue 1996)
        );
    }


    ::rclcpp::Result try_recv_feedback(FeedbackType& feedback) {
        return try_recv_feedback_sized<::rclcpp::rx_buffer_capacity<FeedbackType>::value>(feedback);
    }

    template <size_t Cap>::rclcpp::Result try_recv_feedback_sized(FeedbackType& feedback) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
 
        uint8_t buf[Cap];
        size_t len = 0;
        nros_cpp_ret_t ret = take_feedback(this, buf, sizeof(buf), &len);
        if (ret != 0) return ::rclcpp::Result(ret);
        if (len == 0) return ::rclcpp::Result(::rclcpp::ErrorCode::TryAgain);
        if (FeedbackType::ffi_deserialize(buf, len, &feedback) != 0) {
            return ::rclcpp::Result(::rclcpp::ErrorCode::Error);
        }
        return ::rclcpp::Result::success();
    }

    /// goals for this client — feedback is not goal-scoped at this layer. It
    /// holds the LATEST feedback per client (issue 2011: it used to be one slot
    /// for every action client in the process); an unread one is overwritten.
    /// Callers that need per-goal separation should use the callback API
    /// (`set_callbacks(SendGoalOptions{ .feedback = … })`), which delivers
    /// `(goal_id, bytes, len, ctx)` via an executor-driven trampoline.
    ///
    /// Usage (blocking):
    /// ```cpp
    /// FeedbackType fb;
    /// RCLCPP_TRY(client.feedback_stream().wait_next(executor.handle(), 500, fb));
    /// ```
    ///
    /// Usage (non-blocking):
    /// ```cpp
    /// FeedbackType fb;
    /// Result r = client.feedback_stream().try_next(fb);
    /// if (r.ok()) { ... }
    /// ```
    ::rclcpp::Stream<FeedbackType>& feedback_stream() {
        if (initialized_ && !feedback_stream_.is_valid()) {
            feedback_stream_.bind(this, &Client::take_feedback);
        }
        return feedback_stream_;
    }
 
    const ::rclcpp::Stream<FeedbackType>& feedback_stream() const { return feedback_stream_; }
 
    // =================================================================
    // Async (non-blocking) API — callbacks invoked during spin_once()
    // =================================================================


    /// `result_callback`, taking upstream's shapes (`GoalHandle::SharedPtr`,
    /// `std::shared_ptr<const Feedback>`, `const WrappedResult&`). Those are
    /// read by `async_send_goal`, per goal, as upstream does; the raw pointers
    /// are read by `set_callbacks`, per client. A freestanding build refuses an
    /// assignment to the upstream fields.
    struct SendGoalOptions {
        void (*goal_response)(bool accepted, const uint8_t goal_id[16], void* ctx);
        void (*feedback)(const uint8_t goal_id[16], const uint8_t* data, size_t len, void* ctx);
        void (*result)(const uint8_t goal_id[16], int32_t status, const uint8_t* data, size_t len,
                       void* ctx);
        void* context;

        detail::UpstreamCallback<void(typename GoalHandle::SharedPtr)> goal_response_callback;
        detail::UpstreamCallback<void(typename GoalHandle::SharedPtr, FeedbackPtr)>
            feedback_callback;
        detail::UpstreamCallback<void(const WrappedResult&)> result_callback;
 
        SendGoalOptions() : goal_response(0), feedback(0), result(0), context(0) {}
    };

    ::rclcpp::Result send_goal_async(const GoalType& goal, uint8_t goal_id[16]) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
 
        uint8_t buf[::rclcpp::detail::buffer_bounds<GoalType>::tx];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return ::rclcpp::Result(::rclcpp::ErrorCode::Error);
        }
        return ::rclcpp::Result(nros_cpp_action_client_send_goal_async(
            storage_, buf, len, reinterpret_cast<uint8_t(*)[16]>(goal_id)));
    }

    ::rclcpp::Result send_goal_async(const GoalType& goal, ::rclcpp_action::GoalUUID& goal_id) {
        return send_goal_async(goal, goal_id.data());
    }
 
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
    ::rclcpp::Future<GoalAccept>
    async_send_goal(const GoalType& goal, const SendGoalOptions& options = SendGoalOptions()) {
        uint8_t goal_id[16];
        if (!send_goal_async(goal, goal_id).ok()) return ::rclcpp::Future<GoalAccept>();
        UpstreamState* st = upstream_state();
        prune_upstream(st);
        UpstreamGoal g;
        g.id = GoalUUID(goal_id);
        g.options = options;
        st->goals.push_back(g);
        return ::rclcpp::Future<GoalAccept>(storage_, &nros_cpp_action_client_poll, goal_id,
                                            &accepts_, executor_);
    }
#else
    template <typename T = void>
    ::rclcpp::Future<GoalAccept> async_send_goal(const GoalType&,
                                                 const SendGoalOptions& = SendGoalOptions()) {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_ACTION_GOAL_HANDLE);
        return ::rclcpp::Future<GoalAccept>();
    }
#endif
 
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
    detail::DrivenSharedFuture<WrappedResult>
    async_get_result(typename GoalHandle::SharedPtr goal_handle,
                     ResultCallback result_callback = nullptr) {
        if (!initialized_ || !goal_handle) return detail::DrivenSharedFuture<WrappedResult>();
        typename GoalHandle::ResultState* rs = goal_handle->result_state();
        detail::DrivenSharedFuture<WrappedResult> fut(rs->future, pump_cell());
        if (rs->done) return fut;
        UpstreamState* st = upstream_state();
        size_t at = 0;
        bool created = false;
        if (upstream_goal(goal_handle->get_goal_id().data(), at) == nullptr) {
            UpstreamGoal g;
            g.id = goal_handle->get_goal_id();
            g.accepted = true;
            st->goals.push_back(g);
            at = st->goals.size() - 1;
            created = true;
        }
        if (!goal_handle->result_aware_) {
            if (!get_result_async(goal_handle->get_goal_id()).ok()) {
                if (created) st->goals.erase(st->goals.begin() + static_cast<long>(at));
                return detail::DrivenSharedFuture<WrappedResult>();
            }
            goal_handle->result_aware_ = true;
        }
        UpstreamGoal& g = st->goals[at];
        g.accepted = true;
        g.handle = goal_handle;
        g.weak.reset();
        if (result_callback) g.options.result_callback = result_callback;
        return fut;
    }

    detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>
    async_cancel_goal(typename GoalHandle::SharedPtr goal_handle,
                      CancelCallback cancel_callback = nullptr) {
        if (!goal_handle) return detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>();
        return send_cancel(goal_handle->get_goal_id(), 0, 0, cancel_callback);
    }

    detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>
    async_cancel_all_goals(CancelCallback cancel_callback = nullptr) {
        return send_cancel(GoalUUID(), 0, 0, cancel_callback);
    }

    detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>
    async_cancel_goals_before(const ::rclcpp::Time& stamp,
                              CancelCallback cancel_callback = nullptr) {
        const int64_t ns = stamp.nanoseconds();
        const int64_t sec = ns >= 0 ? ns / 1000000000LL : -((-ns + 999999999LL) / 1000000000LL);
        const int64_t nsec = ns - sec * 1000000000LL;
        return send_cancel(GoalUUID(), static_cast<int32_t>(sec), static_cast<uint32_t>(nsec),
                           cancel_callback);
    }
#endif
#ifndef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
    template <typename T = void, typename... Args> void async_get_result(Args&&...) {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_ACTION_GOAL_HANDLE);
    }

    template <typename T = void, typename... Args> void async_cancel_goal(Args&&...) {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_ACTION_GOAL_HANDLE);
    }

    template <typename T = void, typename... Args> void async_cancel_all_goals(Args&&...) {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_ACTION_GOAL_HANDLE);
    }

    template <typename T = void, typename... Args> void async_cancel_goals_before(Args&&...) {
        static_assert(::rclcpp::detail::refuse<T>::value, NROS_RCLCPP_REFUSE_ACTION_GOAL_HANDLE);
    }
#endif

    ::rclcpp::Result cancel_goal(const uint8_t goal_id[16]) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
        return ::rclcpp::Result(nros_cpp_action_client_cancel_goal(
            storage_, reinterpret_cast<const uint8_t(*)[16]>(goal_id)));
    }

    ::rclcpp::Result cancel_goal(const ::rclcpp_action::GoalUUID& goal_id) {
        return cancel_goal(goal_id.data());
    }

    ::rclcpp::Result try_recv_cancel_response(::rclcpp_action::CancelReturnCode& out) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
        int8_t code = 0;
        // Issue 2034 — a reply the spin took off the wire for a request no
        // future or callback waits on is kept here, not dropped.
        if (take_stray_cancel(code)) {
            out = static_cast<::rclcpp_action::CancelReturnCode>(code);
            return ::rclcpp::Result::success();
        }
        nros_cpp_ret_t ret = nros_cpp_action_client_try_recv_cancel_response(storage_, &code);
        if (ret != 0) return ::rclcpp::Result(ret);
        out = static_cast<::rclcpp_action::CancelReturnCode>(code);
        return ::rclcpp::Result::success();
    }

    ::rclcpp::Result get_result_async(const uint8_t goal_id[16]) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
        return ::rclcpp::Result(nros_cpp_action_client_get_result_async(
            storage_, reinterpret_cast<const uint8_t(*)[16]>(goal_id)));
    }

    ::rclcpp::Result get_result_async(const ::rclcpp_action::GoalUUID& goal_id) {
        return get_result_async(goal_id.data());
    }

    ::rclcpp::Result set_callbacks(const SendGoalOptions& options) {
        if (!initialized_) return ::rclcpp::Result(::rclcpp::ErrorCode::NotInitialized);
        // Issue 2011 -- the client keeps its OWN callbacks installed (they feed
        // the goal-keyed futures and the feedback slot) and forwards to these.
        user_ = options;
        return install_dispatch();
    }

    void poll() {
        if (!initialized_) return;
        // Issue 2034 — cancel replies included: they reach `on_cancel_reply`.
        nros_cpp_action_client_poll(storage_);
    }

    bool is_valid() const { return initialized_; }

    ~Client() {
        abandon_upstream(); // issue 2027 — waiting futures settle; no future names this client
        accepts_.orphan_all();
        results_.orphan_all();
        if (initialized_) {
            nros_cpp_action_client_destroy(storage_);
            initialized_ = false;
        }
        feedback_stream_ = ::rclcpp::Stream<FeedbackType>();
    }
 
    // Move semantics (non-copyable). Relocation goes through the
    // `nros_cpp_action_client_relocate` runtime call (Phase 84.C1), which also
    // RE-POINTS the arena entry's callback `context` at the new `storage_`
    // (issue 1496 — before that, a moved-from temporary left the entry naming
    // dead bytes). The feedback stream is rebound to the new storage afterwards.
    //
    // Issue 2011 -- the pending futures and the client's own callbacks follow
    // it too: both lists move (each future's storage pointer re-targeted) and
    // the callbacks are re-installed with the new address as their context.
    Client(Client&& other)
        : executor_(other.executor_), initialized_(other.initialized_), action_name_{} {
        ::memcpy(action_name_, other.action_name_, sizeof(action_name_));
        adopt(other);
    }
 
    Client& operator=(Client&& other) {
        if (this != &other) {
            abandon_upstream();
            accepts_.orphan_all();
            results_.orphan_all();
            if (initialized_) {
                nros_cpp_action_client_destroy(storage_);
                feedback_stream_ = ::rclcpp::Stream<FeedbackType>();
            }
            executor_ = other.executor_;
            initialized_ = other.initialized_;
            ::memcpy(action_name_, other.action_name_, sizeof(action_name_));
            adopt(other);
        }
        return *this;
    }

    Client() : executor_(nullptr), initialized_(false), action_name_{} {}
 
  private:
    Client(const Client&) = delete;
    Client& operator=(const Client&) = delete;
 
    friend class ::rclcpp::Node;

    ::rclcpp::Result install_dispatch() {
        // Issue 2027 — an abandoned future tells THIS client, which frees the
        // request's slot unless something else still waits on its reply.
        accepts_.forget = &Client::forget_accept;
        accepts_.forget_ctx = this;
        results_.forget = &Client::forget_result;
        results_.forget_ctx = this;
        const nros_cpp_ret_t ret = nros_cpp_action_client_set_callbacks(
            storage_, &Client::on_goal_response, &Client::on_feedback, &Client::on_result, this);
        if (ret != 0) return ::rclcpp::Result(ret);
        // Issue 2034 — the executor's spin takes cancel replies and hands them
        // here (same `this` context).
        return ::rclcpp::Result(
            nros_cpp_action_client_set_cancel_reply_callback(storage_, &Client::on_cancel_reply));
    }
 
    // Issue 2027 — the goal-slot leak. A request in the Rust core's bounded
    // per-sub-client table (`MAX_CONCURRENT_GOALS`) used to come back only
    // with its reply, so a future dropped first — with a reply that never
    // came — held its slot forever, and the fifth such goal refused every
    // later send. The future is the request's owner; when it is abandoned the
    // request is forgotten, UNLESS another owner still waits on that reply:
    // a client-wide callback (`set_callbacks`) or an upstream goal
    // (`async_send_goal` / `async_get_result`). A late reply for a forgotten
    // request is dropped by the correlator.
    static void forget_accept(void* ctx, const uint8_t goal[16]) {
        static_cast<Client*>(ctx)->forget_request(NROS_CPP_ACTION_CHANNEL_SEND_GOAL, goal);
    }
    static void forget_result(void* ctx, const uint8_t goal[16]) {
        static_cast<Client*>(ctx)->forget_request(NROS_CPP_ACTION_CHANNEL_GET_RESULT, goal);
    }
    void forget_request(int32_t channel, const uint8_t goal[16]) {
        if (!initialized_) return;
        const bool accept = channel == NROS_CPP_ACTION_CHANNEL_SEND_GOAL;
        if (accept ? user_.goal_response != nullptr : user_.result != nullptr) return;
        if (upstream_wants(accept, goal)) return;
        (void)nros_cpp_action_client_forget(storage_, channel,
                                            reinterpret_cast<const uint8_t(*)[16]>(goal));
    }

    void adopt(Client& other) {
        user_ = other.user_;
        upstream_ = static_cast<detail::HostedBox&&>(other.upstream_);
        repoint_pump(); // issue 2027 — the futures this client handed out follow it
        feedback_len_ = other.feedback_len_;
        feedback_ready_ = other.feedback_ready_;
        for (size_t i = 0; i < CANCEL_STASH_CAP; ++i)
            stash_codes_[i] = other.stash_codes_[i];
        stash_head_ = other.stash_head_;
        stash_len_ = other.stash_len_;
        other.stash_len_ = 0;
        feedback_truncated_ = other.feedback_truncated_;
        for (size_t i = 0; i < feedback_len_; ++i)
            feedback_buf_[i] = other.feedback_buf_[i];
        other.feedback_ready_ = false;
        if (other.initialized_) {
            nros_cpp_action_client_relocate(other.storage_, storage_);
            other.accepts_.move_to(accepts_, storage_);
            other.results_.move_to(results_, storage_);
            other.initialized_ = false;
            (void)install_dispatch();
        }
        other.feedback_stream_ = ::rclcpp::Stream<FeedbackType>();
    }
 
    // Issue 2011 -- the three callbacks every `Client<A>` keeps installed. The
    // executor's dispatch (and `nros_cpp_action_client_poll`) hands each reply
    // here, attributed to the goal its request named (issue 2009); it goes to
    // the future waiting on THAT goal on THIS client, if any -- dropped
    // otherwise, never handed to another goal -- and then to the user's
    // callback (`set_callbacks`).
    static void on_goal_response(bool accepted, const uint8_t goal_id[16], void* ctx) {
        Client* self = static_cast<Client*>(ctx);
        ::rclcpp::detail::PendingLink* owner = self->accepts_.resolve_goal(goal_id);
        if (owner != nullptr) {
            // The 17-byte layout `GoalAccept::ffi_deserialize` decodes
            // (`nros_cpp_action_goal_accept_decode`).
            uint8_t wire[17];
            for (int i = 0; i < 16; ++i)
                wire[i] = goal_id[i];
            wire[16] = accepted ? 1 : 0;
            self->accepts_.deliver(owner, wire, sizeof(wire));
        }
        self->upstream_goal_response(accepted, goal_id);
        if (self->user_.goal_response != nullptr)
            self->user_.goal_response(accepted, goal_id, self->user_.context);
    }
 
    static void on_feedback(const uint8_t goal_id[16], const uint8_t* data, size_t len, void* ctx) {
        Client* self = static_cast<Client*>(ctx);
        const size_t n = len < sizeof(self->feedback_buf_) ? len : sizeof(self->feedback_buf_);
        for (size_t i = 0; i < n; ++i)
            self->feedback_buf_[i] = data[i];
        self->feedback_len_ = n;
        self->feedback_truncated_ = n < len;
        self->feedback_ready_ = true;
        self->upstream_feedback(goal_id, data, len);
        if (self->user_.feedback != nullptr)
            self->user_.feedback(goal_id, data, len, self->user_.context);
    }
 
    static void on_result(const uint8_t goal_id[16], int32_t status, const uint8_t* data,
                          size_t len, void* ctx) {
        Client* self = static_cast<Client*>(ctx);
        ::rclcpp::detail::PendingLink* owner = self->results_.resolve_goal(goal_id);
        if (owner != nullptr) self->results_.deliver(owner, data, len);
        self->upstream_result(goal_id, status, data, len);
        if (self->user_.result != nullptr)
            self->user_.result(goal_id, status, data, len, self->user_.context);
    }
 
    // Issue 2015 — upstream's per-goal callbacks (`async_send_goal`). Hosted
    // only: `upstream_` is empty on a freestanding build, so these do nothing.
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
    struct UpstreamGoal {
        GoalUUID id;
        SendGoalOptions options;
        typename GoalHandle::SharedPtr handle;
        ::std::weak_ptr<GoalHandle> weak;
        bool accepted = false;
    };
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
    struct CancelWaiter {
        GoalUUID key;
        int64_t seq;
        ::std::promise<typename CancelResponse::SharedPtr> promise;
        CancelCallback callback;
    };
#endif
    struct UpstreamState {
        ::std::vector<UpstreamGoal> goals;
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
        ::std::vector<CancelWaiter> cancels;
#endif
        ::std::shared_ptr<detail::PumpCell> pump;
    };
 
    UpstreamState* upstream_state() {
        UpstreamState* st = upstream_.template as<UpstreamState>();
        if (st == nullptr) {
            st = new UpstreamState();
            upstream_.reset(st, [](void* p) { delete static_cast<UpstreamState*>(p); });
        }
        return st;
    }
 
    UpstreamState* upstream_goal(const uint8_t goal_id[16], size_t& at) const {
        UpstreamState* st = upstream_.template as<UpstreamState>();
        if (st == nullptr) return nullptr;
        const GoalUUID id(goal_id);
        for (at = 0; at < st->goals.size(); ++at)
            if (st->goals[at].id == id) return st;
        return nullptr;
    }

    static void prune_upstream(UpstreamState* st) {
        for (size_t i = 0; i < st->goals.size();) {
            const UpstreamGoal& g = st->goals[i];
            if (g.accepted && !g.handle && g.weak.expired())
                st->goals.erase(st->goals.begin() + static_cast<long>(i));
            else
                ++i;
        }
    }

    ::std::shared_ptr<detail::PumpCell> pump_cell() {
        UpstreamState* st = upstream_state();
        if (!st->pump) {
            st->pump = ::std::make_shared<detail::PumpCell>();
            st->pump->fn = &Client::pump_entry;
        }
        st->pump->ctx = this;
        st->pump->executor = executor_;
        return st->pump;
    }
 
    static void pump_entry(void* ctx) {
        Client* self = static_cast<Client*>(ctx);
        if (!self->initialized_) return;
        (void)nros_cpp_action_client_poll(self->storage_); // cancels too (issue 2034)
    }
#endif

    bool upstream_wants(bool accept, const uint8_t goal_id[16]) {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        size_t at = 0;
        UpstreamState* st = upstream_goal(goal_id, at);
        if (st == nullptr) return false;
        UpstreamGoal& g = st->goals[at];
        if (accept) {
            if (g.accepted) return false;
            const bool wanted = static_cast<bool>(g.options.goal_response_callback) ||
                                static_cast<bool>(g.options.feedback_callback) ||
                                static_cast<bool>(g.options.result_callback);
            if (!wanted) st->goals.erase(st->goals.begin() + static_cast<long>(at));
            return wanted;
        }
        return g.handle && g.handle->result_aware_;
#else
        (void)accept;
        (void)goal_id;
        return false;
#endif
    }

    void repoint_pump() {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        UpstreamState* st = upstream_.template as<UpstreamState>();
        if (st != nullptr && st->pump) {
            st->pump->ctx = this;
            st->pump->executor = executor_;
        }
#endif
    }

    void abandon_upstream() {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        UpstreamState* st = upstream_.template as<UpstreamState>();
        if (st == nullptr) return;
        if (st->pump) st->pump->ctx = nullptr;
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
        for (CancelWaiter& w : st->cancels)
            w.promise.set_value(typename CancelResponse::SharedPtr());
        st->cancels.clear();
        for (UpstreamGoal& g : st->goals) {
            if (g.handle && g.handle->result_aware_) {
                WrappedResult wrapped;
                wrapped.goal_id = g.id;
                wrapped.code = ResultCode::UNKNOWN;
                g.handle->set_result(wrapped);
            }
        }
#endif
        upstream_.reset();
#endif
    }
 
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
    detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>
    send_cancel(const GoalUUID& key, int32_t sec, uint32_t nanosec, CancelCallback& cb) {
        using Fut = detail::DrivenSharedFuture<typename CancelResponse::SharedPtr>;
        if (!initialized_) return Fut();
        int64_t seq = ::rclcpp::detail::SEQUENCE_ID_UNKNOWN;
        if (nros_cpp_action_client_cancel_goals(storage_,
                                                reinterpret_cast<const uint8_t(*)[16]>(key.data()),
                                                sec, nanosec, &seq) != 0)
            return Fut();
        UpstreamState* st = upstream_state();
        CancelWaiter w;
        w.key = key;
        w.seq = seq;
        w.callback = cb;
        ::std::shared_future<typename CancelResponse::SharedPtr> f = w.promise.get_future().share();
        st->cancels.push_back(static_cast<CancelWaiter&&>(w));
        return Fut(f, pump_cell());
    }
#endif

    static void on_cancel_reply(const uint8_t goal[16], int64_t seq, const uint8_t* reply,
                                size_t len, void* ctx) {
        Client* self = static_cast<Client*>(ctx);
        int8_t code = 0;
        size_t count = 0;
        nros_cpp_action_goal_info_t infos[::rclcpp_action::MAX_CANCEL_INFOS];
        const bool taken =
            nros_cpp_action_cancel_reply_decode(reply, len, &code, infos,
                                                ::rclcpp_action::MAX_CANCEL_INFOS, &count) == 0;
        if (self->upstream_cancel_reply(goal, seq, taken, code, infos, count)) return;
        if (taken) self->stash_cancel(code);
    }

    void stash_cancel(int8_t code) {
        if (stash_len_ == CANCEL_STASH_CAP) {
            stash_head_ = static_cast<uint8_t>((stash_head_ + 1) % CANCEL_STASH_CAP);
            --stash_len_;
        }
        stash_codes_[(stash_head_ + stash_len_) % CANCEL_STASH_CAP] = code;
        ++stash_len_;
    }
 
    bool take_stray_cancel(int8_t& code) {
        if (stash_len_ == 0) return false;
        code = stash_codes_[stash_head_];
        stash_head_ = static_cast<uint8_t>((stash_head_ + 1) % CANCEL_STASH_CAP);
        --stash_len_;
        return true;
    }

    bool upstream_cancel_reply(const uint8_t goal[16], int64_t seq, bool taken, int8_t code,
                               const nros_cpp_action_goal_info_t* infos, size_t count) {
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
        UpstreamState* st = upstream_.template as<UpstreamState>();
        if (st == nullptr) return false;
        const GoalUUID key(goal);
        size_t at = 0;
        while (at < st->cancels.size() &&
               !(seq != ::rclcpp::detail::SEQUENCE_ID_UNKNOWN ? st->cancels[at].seq == seq
                                                              : st->cancels[at].key == key))
            ++at;
        if (at == st->cancels.size()) return false;
        CancelWaiter w = static_cast<CancelWaiter&&>(st->cancels[at]);
        st->cancels.erase(st->cancels.begin() + static_cast<long>(at));
        if (!taken) { // malformed: the request is over, with no response
            w.promise.set_value(typename CancelResponse::SharedPtr());
            if (w.callback) w.callback(typename CancelResponse::SharedPtr());
            return true;
        }
        typename CancelResponse::SharedPtr resp = ::std::make_shared<CancelResponse>();
        resp->return_code = code;
        const size_t n =
            count < ::rclcpp_action::MAX_CANCEL_INFOS ? count : ::rclcpp_action::MAX_CANCEL_INFOS;
        for (size_t k = 0; k < n; ++k) {
            detail::CancelGoalInfo info;
            for (int b = 0; b < 16; ++b)
                info.goal_id.uuid[b] = infos[k].uuid[b];
            info.stamp.sec = infos[k].stamp_sec;
            info.stamp.nanosec = infos[k].stamp_nanosec;
            resp->goals_canceling.push_back(info);
        }
        w.promise.set_value(resp);
        if (w.callback) w.callback(resp);
        return true;
#else
        (void)goal;
        (void)seq;
        (void)taken;
        (void)code;
        (void)infos;
        (void)count;
        return false;
#endif
    }
 
    void upstream_goal_response(bool accepted, const uint8_t goal_id[16]) {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        size_t at = 0;
        UpstreamState* st = upstream_goal(goal_id, at);
        if (st == nullptr) return;
        UpstreamGoal& g = st->goals[at];
        if (g.accepted) return; // a duplicate acceptance
        auto cb = g.options.goal_response_callback;
        if (!accepted) {
            st->goals.erase(st->goals.begin() + static_cast<long>(at));
            if (cb) cb(nullptr);
            return;
        }
        typename GoalHandle::SharedPtr handle = ::std::make_shared<GoalHandle>(g.id);
        handle->feedback_aware_ = static_cast<bool>(g.options.feedback_callback);
        handle->result_aware_ = static_cast<bool>(g.options.result_callback);
        g.accepted = true;
        if (handle->result_aware_)
            g.handle = handle; // the pending result request keeps it, as upstream's does
        else
            g.weak = handle; // feedback-only: the caller's copy keeps it
        if (!handle->feedback_aware_ && !handle->result_aware_)
            st->goals.erase(st->goals.begin() + static_cast<long>(at));
        // `g` may be gone from here on: the callback can send another goal.
        if (cb) cb(handle);
        if (handle->result_aware_ && !get_result_async(goal_id).ok()) {
            // Nobody could ever answer it: unbind, as upstream would have thrown.
            handle->result_aware_ = false;
            if (upstream_goal(goal_id, at) != nullptr) {
                st->goals[at].handle.reset();
                st->goals[at].weak = handle;
            }
        }
#else
        (void)accepted;
        (void)goal_id;
#endif
    }
 
    void upstream_feedback(const uint8_t goal_id[16], const uint8_t* data, size_t len) {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        size_t at = 0;
        UpstreamState* st = upstream_goal(goal_id, at);
        if (st == nullptr) return;
        UpstreamGoal& g = st->goals[at];
        typename GoalHandle::SharedPtr handle = g.handle ? g.handle : g.weak.lock();
        if (!handle) {
            // A feedback-only goal whose handle the caller dropped (issue 2027).
            if (g.accepted) st->goals.erase(st->goals.begin() + static_cast<long>(at));
            return;
        }
        auto cb = g.options.feedback_callback;
        if (!cb) return;
        ::std::shared_ptr<FeedbackType> fb = ::std::make_shared<FeedbackType>();
        if (FeedbackType::ffi_deserialize(data, len, fb.get()) != 0) return;
        cb(handle, fb);
#else
        (void)goal_id;
        (void)data;
        (void)len;
#endif
    }
 
    void upstream_result(const uint8_t goal_id[16], int32_t status, const uint8_t* data,
                         size_t len) {
#ifdef NROS_CPP_HAS_SHARED_PTR // hosted-family: action-interop
        size_t at = 0;
        UpstreamState* st = upstream_goal(goal_id, at);
        if (st == nullptr) return;
        UpstreamGoal g = st->goals[at];
        st->goals.erase(st->goals.begin() + static_cast<long>(at));
        typename GoalHandle::SharedPtr handle = g.handle ? g.handle : g.weak.lock();
        if (handle) handle->status_ = static_cast<int8_t>(status);
        WrappedResult wrapped;
        wrapped.goal_id = g.id;
        wrapped.code = (status == 4 || status == 5 || status == 6) ? static_cast<ResultCode>(status)
                                                                   : ResultCode::UNKNOWN;
        wrapped.result = ::std::make_shared<ResultType>();
        if (ResultType::ffi_deserialize(data, len, wrapped.result.get()) != 0) {
            wrapped.result.reset();
        }
#ifdef NROS_CPP_HAS_STD_PROMISE // hosted-family: action-interop
        if (handle) handle->set_result(wrapped);
#endif
        if (g.options.result_callback) g.options.result_callback(wrapped);
#else
        (void)goal_id;
        (void)status;
        (void)data;
        (void)len;
#endif
    }

    static nros_cpp_ret_t take_feedback(void* ctx, uint8_t* buf, size_t cap, size_t* out_len) {
        Client* self = static_cast<Client*>(ctx);
        *out_len = 0;
        if (!self->initialized_)
            return static_cast<nros_cpp_ret_t>(::rclcpp::ErrorCode::NotInitialized);
        if (!self->feedback_ready_) (void)nros_cpp_action_client_poll(self->storage_);
        if (!self->feedback_ready_) return 0;
        self->feedback_ready_ = false;
        if (self->feedback_truncated_ || self->feedback_len_ > cap) {
            *out_len = self->feedback_len_;
            return static_cast<nros_cpp_ret_t>(::rclcpp::ErrorCode::Error);
        }
        for (size_t i = 0; i < self->feedback_len_; ++i)
            buf[i] = self->feedback_buf_[i];
        *out_len = self->feedback_len_;
        return 0;
    }
 
    alignas(8) uint8_t storage_[NROS_CPP_ACTION_CLIENT_STORAGE_SIZE];
    void* executor_; // Stashed executor handle (Phase 82) for blocking helpers
    bool initialized_;
    ::rclcpp::Stream<FeedbackType> feedback_stream_;
    // Phase 87.6 put a `char action_name_[256]` here for an accessor that was
    // never written, and an earlier phase-417 W4.b wave deleted it as dead
    // state. W4.b's second half writes `get_action_name()`, so it is back and
    // it is read — see the note on `Server<A>::get_action_name`.
    char action_name_[::rclcpp_action::ACTION_NAME_MAX];
    ::rclcpp::detail::PendingList accepts_;
    ::rclcpp::detail::PendingList results_;
    SendGoalOptions user_;
    uint8_t feedback_buf_[::rclcpp::rx_buffer_capacity<FeedbackType>::value];
    size_t feedback_len_ = 0;
    bool feedback_ready_ = false;
    bool feedback_truncated_ = false;
    int8_t stash_codes_[CANCEL_STASH_CAP] = {};
    uint8_t stash_head_ = 0;
    uint8_t stash_len_ = 0;
    detail::HostedBox upstream_;
};
 
} // namespace rclcpp_action
 
// Phase 84.G8: out-of-line definition of Node::create_action_client<A>().
#include "rclcpp/node.hpp"
 
namespace rclcpp {} // namespace rclcpp
 
namespace rclcpp {
template <typename A>
Result Node::create_action_client(::rclcpp_action::Client<A>& out, const char* action_name,
                                  const ::rclcpp::QoS& qos) {
    if (!initialized_) return Result(::rclcpp::ErrorCode::NotInitialized);
    nros_cpp_qos_t ffi_qos = ::rclcpp::detail::qos_to_ffi(qos);
    const nros_cpp_action_hashes_t hashes = ::rclcpp::detail::action_endpoint_hashes<A>();
    nros_cpp_ret_t ret = nros_cpp_action_client_create(
        &handle_, action_name, A::TYPE_NAME, A::Goal::TYPE_HASH, &hashes, ffi_qos, out.storage_);
    if (ret == 0) {
        out.executor_ = executor_handle_;
        // Issue 2011 -- the client's own callbacks, from the start: they feed
        // its goal-keyed futures and its feedback slot.
        out.initialized_ = true;
        (void)out.install_dispatch();
        // phase-417 W4.b — remember the name for `get_action_name()`, truncating
        // at `rclcpp_action::ACTION_NAME_MAX` exactly as the server and the polling tiers do.
        ::rclcpp::detail::assign_entity_name(out.action_name_, action_name);
        out.initialized_ = true;
    }
    return Result(ret);
}
} // namespace rclcpp
 
namespace rclcpp {} // namespace rclcpp
 
#endif // NROS_RCLCPP_ACTION_CLIENT_HPP