tsm.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
#if defined(TSM_ENABLE_REFLECTION) && TSM_ENABLE_REFLECTION
#if __has_include(<meta>)
#include <meta>
#else
#error                                                                         \
  "TSM_ENABLE_REFLECTION requires a compiler and standard library with <meta>"
#endif
#endif
 
#include <functional>
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <new>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "tsm/platform/profile.h"
#include "tsm/policies.h"
#include "tsm/runtime/static_ring.h"
#include "tsm/ticks.h"
#include "tsm/transition.h"
#include "tsm/type_list.h"
 
namespace tsm {
namespace detail {
 
 
template<typename From,
         typename Event,
         typename TransitionList,
         size_t Index = 0,
         typename = void>
struct transition_map_helper;
 
template<typename From, typename Event, typename... TransitionEntries, size_t Index>
struct transition_map_helper<
  From,
  Event,
  type_list<TransitionEntries...>,
  Index,
  std::enable_if_t<(Index < sizeof...(TransitionEntries))>> {
    using CurrentTransition =
      std::tuple_element_t<Index, std::tuple<TransitionEntries...>>;
    static constexpr bool match = transition_matches<CurrentTransition, From, Event>;
 
    using type = typename std::conditional_t<
      match,
      CurrentTransition,
      typename transition_map_helper<From,
                                     Event,
                                     type_list<TransitionEntries...>,
                                     Index + 1>::type>;
};
 
template<typename From, typename Event, typename... TransitionEntries, size_t Index>
struct transition_map_helper<
  From,
  Event,
  type_list<TransitionEntries...>,
  Index,
  std::enable_if_t<!(Index < sizeof...(TransitionEntries))>> {
    using type = void;
};
 
template<typename From, typename Event, typename TransitionList>
struct matching_transition {
    using type = typename transition_map_helper<From,
                                                Event,
                                                as_type_list_t<TransitionList>>::type;
};
 
template<typename From, typename Event, typename TransitionList>
using find_transition_t =
  typename matching_transition<From, Event, TransitionList>::type;
 
template<typename State, typename Event, typename TransitionList>
inline constexpr bool has_valid_transition_v =
  !std::is_same_v<typename matching_transition<State, Event, TransitionList>::type,
                  void>;
 
template<typename State, typename Event, typename TransitionList>
concept transition_available =
  has_valid_transition_v<State, Event, TransitionList>;
 
template<typename T>
concept state_has_exit = requires {
    &T::exit;
};
 
template<typename T>
concept state_has_entry = requires {
    &T::entry;
};
 
template<typename T>
concept state_has_guard = requires {
    &T::guard;
};
 
template<typename T>
concept state_has_action = requires {
    &T::action;
};
 
template<typename T>
concept has_hierarchy_c = requires {
    typename T::hierarchy;
};
 
template<typename T, typename = void>
struct context_type_of {
    using type = T;
};
 
template<typename T>
struct context_type_of<T, std::void_t<typename T::context_type>> {
    using type = typename T::context_type;
};
 
template<typename T>
using context_type_of_t = typename context_type_of<T>::type;
 
template<typename T>
concept has_deferred_type_c = requires {
    typename T::deferred;
};
 
template<typename T>
struct deferred_of {
    using type = type_list<>;
};
 
template<typename T>
    requires has_deferred_type_c<T>
struct deferred_of<T> {
    using type = as_type_list_t<typename T::deferred>;
};
 
template<typename T>
using deferred_of_t = typename deferred_of<T>::type;
 
template<typename Deferred>
struct is_defer_rule : std::bool_constant<defer_like<Deferred>> {};
 
template<typename DeferredList>
struct deferred_event_list;
 
template<typename... Deferred>
struct deferred_event_list<type_list<Deferred...>> {
    using type = typename unique_tuple<type_list<typename Deferred::event...>,
                                       type_list<>>::type;
};
 
template<typename DeferredList>
using deferred_event_list_t =
  typename deferred_event_list<DeferredList>::type;
 
template<typename Event, std::size_t Capacity>
struct deferred_event_queue {
    [[nodiscard]] std::uint16_t count() const { return count_; }
 
    bool push(Event const& event) {
        if (count_ >= Capacity) {
            return false;
        }
        storage_[(head_ + count_) % Capacity] = event;
        ++count_;
        return true;
    }
 
    bool pop(Event& event) {
        if (count_ == 0U) {
            return false;
        }
        event = std::move(storage_[head_]);
        head_ = (head_ + 1U) % Capacity;
        --count_;
        return true;
    }
 
    std::array<Event, Capacity> storage_{};
    std::uint16_t head_{};
    std::uint16_t count_{};
};
 
template<typename Events, std::size_t Capacity>
struct deferred_queue_storage;
 
template<typename... Events, std::size_t Capacity>
struct deferred_queue_storage<type_list<Events...>, Capacity> {
    using type = std::tuple<deferred_event_queue<Events, Capacity>...>;
};
 
template<typename Events, std::size_t Capacity>
using deferred_queue_storage_t =
  typename deferred_queue_storage<Events, Capacity>::type;
 
template<typename State, typename Event, typename DeferredList>
struct defers_event : std::false_type {};
 
template<typename State, typename Event, typename... Deferred>
struct defers_event<State, Event, type_list<Deferred...>>
  : std::bool_constant<(
      false || ... ||
      (std::is_same_v<typename Deferred::state, State> &&
       std::is_same_v<typename Deferred::event, Event>))> {};
 
template<typename T>
struct has_transitions : std::bool_constant<has_transitions_c<T>> {};
 
template<typename T>
struct is_unwrapped_state_machine
  : std::bool_constant<has_transitions_c<T> && !requires { T::is_hsm; }> {};
 
template<typename T>
inline constexpr bool has_transitions_v = has_transitions_c<T>;
 
template<typename State, typename Event, typename Context>
concept state_handles_event = requires(State& state, Context& ctx, Event& event) {
    { state.handle(ctx, event) } -> std::convertible_to<bool>;
};
 
template<typename T>
concept hsm_like = requires {
    T::is_hsm;
};
 
template<typename T>
struct is_hsm_trait : std::bool_constant<hsm_like<T>> {};
 
template<typename T>
inline constexpr bool is_hsm_trait_v = hsm_like<T>;
 
template<typename T>
inline constexpr bool is_state_trait_v = has_transitions_c<T> && !hsm_like<T>;
 
template<typename T>
concept clocked_hsm_like = requires {
    T::is_clocked_hsm;
};
 
template<typename T>
struct is_clocked_hsm : std::bool_constant<clocked_hsm_like<T>> {};
 
template<typename T>
inline constexpr bool is_clocked_hsm_v = clocked_hsm_like<T>;
 
template<typename...>
inline constexpr bool dependent_false_v = false;
 
template<typename Callable, typename Context, typename Event>
concept guard_with_context_event =
  requires(Callable&& callable, Context& ctx, Event& event) {
      { std::invoke(std::forward<Callable>(callable), ctx, event) } -> std::same_as<bool>;
  };
 
template<typename Callable, typename Context>
concept guard_with_context =
  requires(Callable&& callable, Context& ctx) {
      { std::invoke(std::forward<Callable>(callable), ctx) } -> std::same_as<bool>;
  };
 
template<typename Callable, typename Event>
concept guard_with_event =
  requires(Callable&& callable, Event& event) {
      { std::invoke(std::forward<Callable>(callable), event) } -> std::same_as<bool>;
  };
 
template<typename Callable>
concept guard_without_args =
  requires(Callable&& callable) {
      { std::invoke(std::forward<Callable>(callable)) } -> std::same_as<bool>;
  };
 
template<typename Callable, typename Context, typename Event>
concept transition_guard =
  guard_with_context_event<Callable, Context, Event> ||
  guard_with_context<Callable, Context> ||
  guard_with_event<Callable, Event> ||
  guard_without_args<Callable>;
 
template<typename Callable, typename Context, typename Event>
bool invoke_guard(Callable&& callable, Context& ctx, Event& e) {
    if constexpr (guard_with_context_event<Callable, Context, Event>) {
        return std::invoke(std::forward<Callable>(callable), ctx, e);
    } else if constexpr (guard_with_context<Callable, Context>) {
        return std::invoke(std::forward<Callable>(callable), ctx);
    } else if constexpr (guard_with_event<Callable, Event>) {
        return std::invoke(std::forward<Callable>(callable), e);
    } else if constexpr (guard_without_args<Callable>) {
        return std::invoke(std::forward<Callable>(callable));
    } else {
        static_assert(dependent_false_v<Callable, Context, Event>,
                      "tsm: transition guard must have one of these exact signatures: bool(Context&, Event&), bool(Context&, Event const&), bool(Context&), bool(Event&), bool(Event const&), or bool()");
    }
}
 
template<typename Callable, typename Context, typename Event>
concept action_with_context_event =
  requires(Callable&& callable, Context& ctx, Event& event) {
      { std::invoke(std::forward<Callable>(callable), ctx, event) } -> std::same_as<void>;
  };
 
template<typename Callable, typename Context>
concept action_with_context =
  requires(Callable&& callable, Context& ctx) {
      { std::invoke(std::forward<Callable>(callable), ctx) } -> std::same_as<void>;
  };
 
template<typename Callable, typename Event>
concept action_with_event =
  requires(Callable&& callable, Event& event) {
      { std::invoke(std::forward<Callable>(callable), event) } -> std::same_as<void>;
  };
 
template<typename Callable>
concept action_without_args =
  requires(Callable&& callable) {
      { std::invoke(std::forward<Callable>(callable)) } -> std::same_as<void>;
  };
 
template<typename Callable, typename Context, typename Event>
concept transition_action =
  action_with_context_event<Callable, Context, Event> ||
  action_with_context<Callable, Context> ||
  action_with_event<Callable, Event> ||
  action_without_args<Callable>;
 
template<typename Callable, typename Context, typename Event>
void invoke_action(Callable&& callable, Context& ctx, Event& e) {
    if constexpr (action_with_context_event<Callable, Context, Event>) {
        std::invoke(std::forward<Callable>(callable), ctx, e);
    } else if constexpr (action_with_context<Callable, Context>) {
        std::invoke(std::forward<Callable>(callable), ctx);
    } else if constexpr (action_with_event<Callable, Event>) {
        std::invoke(std::forward<Callable>(callable), e);
    } else if constexpr (action_without_args<Callable>) {
        std::invoke(std::forward<Callable>(callable));
    } else {
        static_assert(dependent_false_v<Callable, Context, Event>,
                      "tsm: transition action must have one of these exact signatures: void(Context&, Event&), void(Context&, Event const&), void(Context&), void(Event&), void(Event const&), or void()");
    }
}
 
} // namespace detail
} // namespace tsm
 
#include "tsm/core_algorithms.h"
 
namespace tsm {
namespace detail {
 
template<typename T>
struct state_slot {
    T value{};
};
 
template<typename List>
struct state_storage;
 
template<typename... States>
struct state_storage<type_list<States...>> : state_slot<States>... {
    template<typename State>
    State& get() noexcept {
        return state_slot<State>::value;
    }
 
    template<typename State>
    State const& get() const noexcept {
        return state_slot<State>::value;
    }
};
 
template<typename Hierarchy, typename AuthoredTransitionList, typename = void>
struct hierarchy_transition_list {
    using type = AuthoredTransitionList;
};
 
template<typename Hierarchy, typename AuthoredTransitionList>
struct hierarchy_transition_list<
  Hierarchy,
  AuthoredTransitionList,
  std::void_t<typename Hierarchy::transitions>> {
    using type = typename Hierarchy::transitions;
};
 
template<typename Context, bool HasExplicitHierarchy>
struct context_hierarchy_type {
    using type = tsm::core::infer_hierarchy_t<Context>;
};
 
template<typename Context>
struct context_hierarchy_type<Context, true> {
    using type = typename Context::hierarchy;
};
 
template<typename Context,
         typename AuthoredTransitionList,
         typename CoreTable,
         bool HasHierarchy>
struct hsm_state_model {
    using hierarchy = void;
    using transitions = AuthoredTransitionList;
    using states = typename CoreTable::states;
};
 
template<typename Context, typename AuthoredTransitionList, typename CoreTable>
struct hsm_state_model<Context, AuthoredTransitionList, CoreTable, true> {
    using hierarchy =
      typename context_hierarchy_type<Context, has_hierarchy_c<Context>>::type;
    using transitions =
      typename hierarchy_transition_list<hierarchy, AuthoredTransitionList>::type;
    using states = typename hierarchy::states;
};
 
template<typename Definition>
using transition_entries_t =
  filter_type_list_t<is_transition, as_type_list_t<Definition>>;
 
template<typename Definition>
using synchronization_entries_t =
  filter_type_list_t<is_synchronization_rule, as_type_list_t<Definition>>;
 
 
template<typename T,
         typename DefinitionEntries = transitions_of_t<T>,
         typename Configuration = tsm::policy::Configuration<>>
struct hsm {
    static constexpr bool is_hsm = true;
    using type = hsm<T, DefinitionEntries, Configuration>;
    using HsmType = type; // alias for policy classes
    using definition = T;
    using context_type = context_type_of_t<T>;
    using configuration = Configuration;
    using semantics_policy = typename configuration::semantics;
    using runtime_policy = typename configuration::runtime;
    using logging_policy = typename configuration::logging;
    using sequence_policy = typename semantics_policy::precompute_sequences;
    using authored_definition_list = as_type_list_t<DefinitionEntries>;
    using authored_transition_list =
      transition_entries_t<authored_definition_list>;
    using authored_synchronization_list =
      synchronization_entries_t<authored_definition_list>;
    static_assert(!empty_type_list_v<authored_transition_list>,
                  "tsm: hsm requires at least one event transition");
    using deferred_list = deferred_of_t<T>;
    static_assert(
      type_list_traits::all_satisfy<is_defer_rule, deferred_list>::value,
      "tsm: deferred must be tsm::type_list<tsm::defer<State, Event>...>");
    using authored_core_table =
      tsm::core::transition_table<authored_transition_list>;
    static_assert(authored_core_table::valid_triggers,
                  "tsm: duplicate (from, event) transitions are only allowed "
                  "when all duplicates are guarded, or for choice/junction "
                  "automatic transitions with at most one unguarded fallback");
    static constexpr bool has_composite_states =
      type_list_traits::any_satisfy<
        is_unwrapped_state_machine,
        typename authored_core_table::states>::value;
    static constexpr bool has_hierarchy =
      has_hierarchy_c<T> || has_composite_states;
    using state_model =
      hsm_state_model<T,
                      authored_transition_list,
                      authored_core_table,
                      has_hierarchy>;
    using hierarchy_type = typename state_model::hierarchy;
    using transition_list = typename state_model::transitions;
    using transitions = transition_list;
    using core_table = tsm::core::transition_table<transition_list>;
    using initial_state = typename front_type_t<transition_list>::from;
    using state_list = typename state_model::states;
    using runtime_state_set = tsm::core::type_set<state_list>;
    using States = state_storage<state_list>;
    static constexpr std::size_t state_count = runtime_state_set::size;
    static constexpr std::size_t transition_count =
      core_table::transition_count;
    static constexpr std::size_t first_transition_index = 0U;
    using history_storage =
      typename semantics_policy::history::template storage<state_count>;
    using deferred_events = deferred_event_list_t<deferred_list>;
    using deferred_event_set = tsm::core::type_set<deferred_events>;
    static constexpr std::size_t deferred_event_count =
      deferred_event_set::size;
    static constexpr std::size_t deferred_capacity =
      semantics_policy::deferred::capacity;
    using deferred_queues =
      deferred_queue_storage_t<deferred_events, deferred_capacity>;
 
    hsm()
        requires std::default_initializable<context_type>
      : context_{},
        active_state_(state_index<initial_state>()) {
        reset_active_path();
    }
 
    explicit hsm(context_type const& context)
        requires std::copy_constructible<context_type>
      : context_(context),
        active_state_(state_index<initial_state>()) {
        reset_active_path();
    }
 
    explicit hsm(context_type&& context)
        requires std::move_constructible<context_type>
      : context_(std::move(context)),
        active_state_(state_index<initial_state>()) {
        reset_active_path();
    }
 
    [[nodiscard]] context_type& context() noexcept { return context_; }
 
    [[nodiscard]] context_type const& context() const noexcept { return context_; }
 
    [[nodiscard]] context_type& ctx() noexcept { return context_; }
 
    [[nodiscard]] context_type const& ctx() const noexcept { return context_; }
 
    template<typename State>
    static consteval std::uint16_t state_index() {
        return runtime_state_set::template index<State>();
    }
 
    [[nodiscard]] constexpr std::uint16_t active_state_id() const noexcept {
        return active_state_;
    }
 
    [[nodiscard]] constexpr auto const& active_path() const noexcept {
        return active_path_;
    }
 
    template<typename State>
    [[nodiscard]] bool active() const noexcept {
        return active_state_ == state_index<State>();
    }
 
    template<typename Parent>
    [[nodiscard]] bool active_final() const noexcept {
        return active_final_id<Parent, 0U>();
    }
 
    template<typename State>
    State& state() noexcept {
        return states_.template get<State>();
    }
 
    template<typename State>
    State const& state() const noexcept {
        return states_.template get<State>();
    }
 
    template<typename Event>
    void enter(Event& e) {
        active_state_ = state_index<initial_state>();
        reset_active_path();
        this->entry(e, &state<initial_state>());
    }
 
    template<typename Event>
    void leave(Event& e) {
        dispatch_exit<0>(e);
    }
 
    template<typename Event>
    bool handle(Event&& e) {
        log_debug(tsm::log::Kind::Event, event_record<std::decay_t<Event>>());
        bool handled = false;
        if constexpr (has_hierarchy) {
            handled = dispatch_hierarchy_path(e);
        } else {
            handled = dispatch_handle<0>(e);
        }
        bool deferred_now = false;
        if (!handled) {
            if (!recalling_deferred_ &&
                should_defer_event<std::decay_t<Event>>()) {
                handled = defer_event(e);
                deferred_now = handled;
            } else {
                log_warn(tsm::log::Kind::Unhandled,
                         event_record<std::decay_t<Event>>());
            }
        }
        if (handled && !deferred_now && !recalling_deferred_) {
            recall_deferred_events();
        }
        return handled;
    }
 
    template<typename Event, typename State>
    void entry(Event&& e, State* state) noexcept {
        log_debug(tsm::log::Kind::Entry,
                  state_record<State, std::decay_t<Event>>());
        if constexpr (state_has_entry<State>) {
            if constexpr (std::is_invocable_v<decltype(&State::entry),
                                              State*,
                                              context_type&,
                                              decltype(e)>) {
                state->entry(context_, e);
            } else if constexpr (std::is_invocable_v<decltype(&State::entry),
                                                     State*,
                                                     context_type&>) {
                state->entry(context_);
            } else if constexpr (std::is_invocable_v<decltype(&State::entry),
                                                     State*>) {
                state->entry();
            } else {
                static_assert(dependent_false_v<State, Event>,
                              "tsm: state entry must have one of these exact signatures: void(Context&, Event&), void(Context&, Event const&), void(Context&), void(Event&), void(Event const&), or void()");
            }
        }
        if constexpr (is_hsm_trait_v<State>) {
            state->enter(e);
        }
    }
 
    template<typename Event, typename State>
    void exit(Event&& e, State* state) noexcept {
        log_debug(tsm::log::Kind::Exit,
                  state_record<State, std::decay_t<Event>>());
        if constexpr (is_hsm_trait_v<State>) {
            state->leave(e);
        }
        if constexpr (state_has_exit<State>) {
            if constexpr (std::is_invocable_v<decltype(&State::exit),
                                              State*,
                                              context_type&,
                                              decltype(e)>) {
                state->exit(context_, e);
            } else if constexpr (std::is_invocable_v<decltype(&State::exit),
                                                     State*,
                                                     context_type&>) {
                state->exit(context_);
            } else if constexpr (std::is_invocable_v<decltype(&State::exit),
                                                     State*>) {
                state->exit();
            } else {
                static_assert(dependent_false_v<State, Event>,
                              "tsm: state exit must have one of these exact signatures: void(Context&, Event&), void(Context&, Event const&), void(Context&), void(Event&), void(Event const&), or void()");
            }
        }
    }
    template<typename Tn, typename Event, typename State>
    bool check_guard(Event& e, State* state) {
        if constexpr (state_has_guard<State>) {
            if constexpr (std::is_invocable_v<decltype(&State::guard),
                                              State*,
                                              context_type&,
                                              decltype(e)>) {
                return state->guard(context_, e);
            } else if constexpr (std::is_invocable_v<decltype(&State::guard),
                                                     State*,
                                                     context_type&>) {
                return state->guard(context_);
            } else if constexpr (std::is_invocable_v<decltype(&State::guard),
                                                     State*>) {
                return state->guard();
            } else {
                static_assert(dependent_false_v<Tn, Event, State>,
                              "tsm: state guard must have one of these exact signatures: bool(Context&, Event&), bool(Context&, Event const&), bool(Context&), bool(Event&), bool(Event const&), or bool()");
            }
        } else {
            if constexpr (transition_has_guard<Tn>) {
                return invoke_guard(Tn::guard, context_, e);
            } else {
                return true;
            }
        }
    }
 
    template<typename Tn, typename Event, typename State>
    void perform_action(Event& e, State* state) {
        if constexpr (state_has_action<State>) {
            if constexpr (std::is_invocable_v<decltype(&State::action),
                                              State*,
                                              context_type&,
                                              decltype(e)>) {
                state->action(context_, e);
            } else if constexpr (std::is_invocable_v<decltype(&State::action),
                                                     State*,
                                                     context_type&>) {
                state->action(context_);
            } else if constexpr (std::is_invocable_v<decltype(&State::action),
                                                     State*>) {
                state->action();
            } else {
                static_assert(dependent_false_v<Tn, Event, State>,
                              "tsm: state action must have one of these exact signatures: void(Context&, Event&), void(Context&, Event const&), void(Context&), void(Event&), void(Event const&), or void()");
            }
        } else {
            if constexpr (transition_has_action<Tn>) {
                log_debug(tsm::log::Kind::Action,
                          transition_record<Tn, Event>());
                invoke_action(Tn::action, context_, e);
            }
        }
    }
 
    template<typename transition,
             typename Event,
             typename State = typename transition::from>
        requires (!state_handles_event<State, Event, context_type>)
    bool
    handle_transition(State* current, Event& e) {
        if (!this->check_guard<transition>(e, current)) {
            log_warn(tsm::log::Kind::GuardRejected,
                     transition_record<transition, Event>());
            return false;
        }
 
        return execute_transition<transition>(current, e);
    }
 
    template<typename transition,
             typename Event,
             typename State = typename transition::from>
        requires state_handles_event<State, Event, context_type>
    bool
    handle_transition(State* current, Event& e) {
 
        if (!current->handle(context_, e)) {
            log_warn(tsm::log::Kind::GuardRejected,
                     transition_record<transition, Event>());
            return false;
        }
 
        return execute_transition<transition>(current, e);
    }
 
    template<typename transition, typename Event, typename State>
    bool execute_transition(State* current, Event& e) {
        if constexpr (transition_traits<transition>::kind ==
                      transition_kind::internal) {
            this->perform_action<transition>(e, current);
            return true;
        } else
        if constexpr (has_hierarchy) {
            using to = typename transition::to;
            const auto destination = resolve_destination<to>();
            if constexpr (transition_traits<transition>::kind ==
                          transition_kind::reentering_external) {
                constexpr auto selected_source =
                  state_index<typename transition::from>();
                const auto sequence =
                  tsm::core::compute_reentering_transition_sequence<hierarchy_type>(
                    active_state_,
                    selected_source,
                    destination);
                return apply_transition_sequence<transition>(
                  sequence, destination, current, e);
            } else
            if constexpr (transition_traits<transition>::kind ==
                          transition_kind::local) {
                constexpr auto selected_source =
                  state_index<typename transition::from>();
                const auto sequence =
                  tsm::core::compute_local_transition_sequence<hierarchy_type>(
                    active_state_,
                    selected_source,
                    destination);
                return apply_transition_sequence<transition>(
                  sequence, destination, current, e);
            } else {
                if constexpr (can_precompute_sequence<transition>()) {
                    constexpr auto sequence =
                      precomputed_sequence<transition>();
                    return apply_transition_sequence<transition>(
                      sequence, sequence.destination, current, e);
                } else
                if constexpr (can_precompute_active_leaf_sequences<transition>()) {
                    auto const& sequence =
                      precomputed_sequence_for_active_leaf<transition>(
                        active_state_);
                    return apply_transition_sequence<transition>(
                      sequence, sequence.destination, current, e);
                } else {
                    const auto sequence =
                      tsm::core::compute_transition_sequence<hierarchy_type>(
                        active_state_,
                        destination);
                    return apply_transition_sequence<transition>(
                      sequence, destination, current, e);
                }
            }
        } else {
            log_info(tsm::log::Kind::Transition,
                     transition_record<transition, Event>());
            this->exit(e, current);
 
            this->perform_action<transition>(e, current);
 
            using to = typename transition::to;
            active_state_ = state_index<to>();
            reset_active_path();
 
            this->entry(e, &state<to>());
            resolve_decision_pseudostate<to>();
            return true;
        }
    }
 
    template<typename transition, typename Sequence, typename Event, typename State>
    bool apply_transition_sequence(Sequence const& sequence,
                                   std::uint16_t destination,
                                   State* current,
                                   Event& e) {
        if (sequence.lca == tsm::core::npos) {
            log_error(tsm::log::Kind::Transition,
                      transition_record<transition, Event>());
            return false;
        }
 
        log_info(tsm::log::Kind::Transition,
                 transition_record<transition, Event>());
 
        for (std::size_t i = 0; i < sequence.exits.size; ++i) {
            dispatch_exit_id<0>(sequence.exits[i], e);
        }
 
        this->perform_action<transition>(e, current);
 
        active_state_ =
          sequence.final_path.size == 0U
            ? destination
            : sequence.final_path[sequence.final_path.size - 1U];
        active_path_ = sequence.final_path;
 
        for (std::size_t i = 0; i < sequence.entries.size; ++i) {
            dispatch_entry_id<0>(sequence.entries[i], e);
        }
        resolve_decision_pseudostate_id(destination);
        return true;
    }
 
    template<typename Transition, typename ActiveState>
    static consteval auto precomputed_sequence_from_active_leaf() {
        // Parent-sourced transitions are authored at a composite state, but the
        // active source at runtime is one of that parent's descendant leaves.
        // This builds one candidate sequence for each possible active leaf.
        constexpr auto active_leaf = state_index<ActiveState>();
        constexpr auto selected_source =
          state_index<typename Transition::from>();
        constexpr auto destination = state_index<typename Transition::to>();
 
        if constexpr (hierarchy_type::least_common_ancestor(active_leaf,
                                                            selected_source) ==
                      selected_source) {
            return tsm::core::compute_transition_sequence<hierarchy_type>(
              active_leaf,
              destination);
        } else {
            tsm::core::transition_sequence<hierarchy_type::max_depth> invalid{};
            invalid.destination = destination;
            return invalid;
        }
    }
 
    template<typename Transition, typename States>
    struct precomputed_sequence_table;
 
    template<typename Transition, typename... States>
    struct precomputed_sequence_table<Transition, type_list<States...>> {
        using sequence_type =
          tsm::core::transition_sequence<hierarchy_type::max_depth>;
        static constexpr std::array<sequence_type, sizeof...(States)> value{
          precomputed_sequence_from_active_leaf<Transition, States>()...
        };
    };
 
    template<typename Transition>
    static consteval bool can_precompute_sequence() {
        // Leaf-sourced external transitions have a single static source and a
        // single concrete destination, so the full exit/entry sequence can be a
        // compile-time constant.
        if constexpr (!has_hierarchy || !sequence_policy::enabled) {
            return false;
        } else if constexpr (history_state_like<typename Transition::to> ||
                             deep_history_state_like<typename Transition::to>) {
            return false;
        } else {
            constexpr auto source =
              state_index<typename Transition::from>();
            return hierarchy_type::initial_child_index(source) ==
                   tsm::core::npos;
        }
    }
 
    template<typename Transition>
    static consteval bool can_precompute_active_leaf_sequences() {
        // Composite-sourced external transitions can still be precomputed, but
        // the selected sequence depends on the currently active descendant.
        if constexpr (!has_hierarchy || !sequence_policy::enabled) {
            return false;
        } else if constexpr (transition_traits<Transition>::kind !=
                             transition_kind::external) {
            return false;
        } else if constexpr (history_state_like<typename Transition::to> ||
                             deep_history_state_like<typename Transition::to>) {
            return false;
        } else {
            constexpr auto source =
              state_index<typename Transition::from>();
            return hierarchy_type::initial_child_index(source) !=
                   tsm::core::npos;
        }
    }
 
    template<typename Transition>
    static consteval auto precomputed_sequence() {
        constexpr auto source = state_index<typename Transition::from>();
        constexpr auto destination = state_index<typename Transition::to>();
        return tsm::core::compute_transition_sequence<hierarchy_type>(
          source,
          destination);
    }
 
    template<typename Transition>
    static constexpr auto const& precomputed_sequence_for_active_leaf(
      std::uint16_t active_leaf) {
        using table =
          precomputed_sequence_table<Transition, state_list>;
        return table::value[active_leaf];
    }
 
    template<typename Destination>
    [[nodiscard]] std::uint16_t resolve_destination() const {
        if constexpr (deep_history_state_like<Destination>) {
            constexpr auto parent =
              state_index<typename Destination::history_parent>();
            const auto remembered = history_.get(parent);
            if (remembered != tsm::core::npos) {
                return deep_history_leaf(remembered);
            }
            const auto initial = hierarchy_type::initial_child_index(parent);
            return initial == tsm::core::npos ? parent : deep_history_leaf(initial);
        } else if constexpr (history_state_like<Destination>) {
            constexpr auto parent =
              state_index<typename Destination::history_parent>();
            const auto remembered = history_.get(parent);
            if (remembered != tsm::core::npos) {
                return remembered;
            }
            const auto initial = hierarchy_type::initial_child_index(parent);
            return initial == tsm::core::npos ? parent : initial;
        } else {
            return state_index<Destination>();
        }
    }
 
    [[nodiscard]] std::uint16_t deep_history_leaf(std::uint16_t state_id) const {
        if constexpr (has_hierarchy) {
            while (true) {
                const auto remembered = history_.get(state_id);
                if (remembered != tsm::core::npos) {
                    state_id = remembered;
                    continue;
                }
                const auto initial = hierarchy_type::initial_child_index(state_id);
                if (initial == tsm::core::npos) {
                    return state_id;
                }
                state_id = initial;
            }
        } else {
            return state_id;
        }
    }
 
    template<std::size_t Index, typename Event>
    bool dispatch_handle(Event& e) {
        if constexpr (Index >= state_count) {
            return false;
        } else {
            switch (active_state_) {
            case Index:
                return handle_active_state<type_at_t<Index, state_list>>(e);
            default:
                return dispatch_handle<Index + 1U>(e);
            }
        }
    }
 
    template<typename State, typename Event>
    bool handle_active_state(Event& e) {
        return handle_source_state<State>(e);
    }
 
    template<typename State, typename Event>
    bool handle_source_state(Event& e) {
        auto* current = &state<State>();
        bool handled = false;
        if constexpr (is_hsm_trait_v<State>) {
            if (active_state_ == state_index<State>()) {
                handled = current->handle(e);
            }
        }
        if (!handled) {
            if constexpr (transition_available<State,
                                               std::decay_t<Event>,
                                               transition_list>) {
                handled =
                  handle_matching_transitions<State,
                                             Event,
                                             first_transition_index>(
                    current,
                    e);
            }
        }
        return handled;
    }
 
    template<typename State, typename Event, std::size_t Index>
    bool handle_matching_transitions(State* current, Event& e) {
        if constexpr (Index >= transition_count) {
            return false;
        } else {
            using transition = type_at_t<Index, transition_list>;
            if constexpr (transition_matches<transition,
                                             State,
                                             std::decay_t<Event>>) {
                if (handle_transition<transition>(current, e)) {
                    return true;
                }
            }
            return handle_matching_transitions<State, Event, Index + 1U>(
              current,
              e);
        }
    }
 
    template<typename Event>
    bool dispatch_hierarchy_path(Event& e) {
        for (std::size_t i = active_path_.size; i > 0U; --i) {
            if (dispatch_source_id<0>(active_path_[i - 1U], e)) {
                return true;
            }
        }
        return false;
    }
 
    template<std::size_t Index, typename Event>
    bool dispatch_source_id(std::uint16_t state_id, Event& e) {
        if constexpr (Index >= state_count) {
            return false;
        } else {
            if (state_id == Index) {
                return handle_source_state<type_at_t<Index, state_list>>(e);
            }
            return dispatch_source_id<Index + 1U>(state_id, e);
        }
    }
 
    template<typename Parent, std::size_t Index>
    [[nodiscard]] bool active_final_id() const noexcept {
        if constexpr (Index >= state_count) {
            return false;
        } else {
            using State = type_at_t<Index, state_list>;
            if constexpr (final_state_like<State>) {
                if constexpr (std::is_same_v<typename State::final_parent,
                                             Parent>) {
                    return active_state_ == Index;
                } else {
                    return active_final_id<Parent, Index + 1U>();
                }
            } else {
                return active_final_id<Parent, Index + 1U>();
            }
        }
    }
 
    template<std::size_t Index, typename Event>
    void dispatch_exit(Event& e) {
        if constexpr (Index < state_count) {
            switch (active_state_) {
            case Index:
                exit(e, &state<type_at_t<Index, state_list>>());
                break;
            default:
                dispatch_exit<Index + 1U>(e);
                break;
            }
        }
    }
 
    template<std::size_t Index, typename Event>
    void dispatch_exit_id(std::uint16_t state_id, Event& e) {
        if constexpr (Index < state_count) {
            if (state_id == Index) {
                remember_history(state_id);
                exit(e, &state<type_at_t<Index, state_list>>());
            } else {
                dispatch_exit_id<Index + 1U>(state_id, e);
            }
        }
    }
 
    void remember_history(std::uint16_t state_id) {
        if constexpr (has_hierarchy) {
            const auto parent = hierarchy_type::parent_index(state_id);
            if (parent != tsm::core::npos) {
                history_.set(parent, state_id);
            }
        }
    }
 
    template<std::size_t Index, typename Event>
    void dispatch_entry_id(std::uint16_t state_id, Event& e) {
        if constexpr (Index < state_count) {
            if (state_id == Index) {
                entry(e, &state<type_at_t<Index, state_list>>());
            } else {
                dispatch_entry_id<Index + 1U>(state_id, e);
            }
        }
    }
 
    template<typename State>
    void resolve_decision_pseudostate() {
        if constexpr (decision_pseudostate_like<State>) {
            automatic_event event{};
            (void)this->handle(event);
        }
    }
 
    void resolve_decision_pseudostate_id(std::uint16_t state_id) {
        dispatch_decision_pseudostate_id<0U>(state_id);
    }
 
    template<std::size_t Index>
    void dispatch_decision_pseudostate_id(std::uint16_t state_id) {
        if constexpr (Index < state_count) {
            if (state_id == Index) {
                using State = type_at_t<Index, state_list>;
                resolve_decision_pseudostate<State>();
            } else {
                dispatch_decision_pseudostate_id<Index + 1U>(state_id);
            }
        }
    }
 
    template<typename State>
    void current_state() {
        active_state_ = state_index<State>();
        reset_active_path();
    }
 
    template<typename Event>
    [[nodiscard]] std::uint16_t deferred_count() const {
        if constexpr (deferred_event_set::template contains<Event>()) {
            return deferred_queue<Event>().count();
        } else {
            return 0U;
        }
    }
 
    void reset_active_path() {
        if constexpr (has_hierarchy) {
            active_path_ = hierarchy_type::path_from_root(active_state_);
        } else {
            active_path_ = {};
            active_path_.push_back(active_state_);
        }
    }
 
    template<typename Event>
    static consteval std::uint16_t event_index() {
        return core_table::template event_index<Event>();
    }
 
    template<typename Event>
    static consteval std::uint16_t deferred_event_index() {
        return deferred_event_set::template index<Event>();
    }
 
    template<typename Event>
    static consteval tsm::log::Record event_record() {
        return { tsm::tick_duration{},
                 tsm::log::Kind::Event,
                 tsm::core::npos,
                 active_state_placeholder(),
                 event_index<Event>(),
                 tsm::core::npos,
                 tsm::core::npos };
    }
 
    template<typename State, typename Event>
    static consteval tsm::log::Record state_record() {
        return { tsm::tick_duration{},
                 tsm::log::Kind::Entry,
                 tsm::core::npos,
                 state_index<State>(),
                 event_index<Event>(),
                 tsm::core::npos,
                 tsm::core::npos };
    }
 
    template<typename Transition, typename Event>
    static consteval tsm::log::Record transition_record() {
        return { tsm::tick_duration{},
                 tsm::log::Kind::Transition,
                 tsm::core::npos,
                 state_index<typename Transition::from>(),
                 event_index<std::decay_t<Event>>(),
                 state_index<typename Transition::to>(),
                 core_table::template transition_type_index<Transition>() };
    }
 
    static consteval std::uint16_t active_state_placeholder() {
        return tsm::core::npos;
    }
 
    constexpr void log_debug(tsm::log::Kind kind,
                             tsm::log::Record const& record) {
        if constexpr (logging_policy::enabled) {
            auto event = record;
            event.kind = kind;
            logger_.debug(kind, event);
        }
    }
 
    constexpr void log_info(tsm::log::Kind kind,
                            tsm::log::Record const& record) {
        if constexpr (logging_policy::enabled) {
            auto event = record;
            event.kind = kind;
            logger_.info(kind, event);
        }
    }
 
    constexpr void log_warn(tsm::log::Kind kind,
                            tsm::log::Record const& record) {
        if constexpr (logging_policy::enabled) {
            auto event = record;
            event.kind = kind;
            logger_.warn(kind, event);
        }
    }
 
    constexpr void log_error(tsm::log::Kind kind,
                             tsm::log::Record const& record) {
        if constexpr (logging_policy::enabled) {
            auto event = record;
            event.kind = kind;
            logger_.error(kind, event);
        }
    }
 
    template<typename Event>
    bool should_defer_event() const {
        if constexpr (deferred_event_set::template contains<Event>()) {
            if constexpr (has_hierarchy) {
                for (std::size_t i = active_path_.size; i > 0U; --i) {
                    if (dispatch_defer_source_id<Event, 0U>(
                          active_path_[i - 1U])) {
                        return true;
                    }
                }
                return false;
            } else {
                return dispatch_defer_source_id<Event, 0U>(active_state_);
            }
        } else {
            return false;
        }
    }
 
    template<typename Event, std::size_t Index>
    bool dispatch_defer_source_id(std::uint16_t state_id) const {
        if constexpr (Index >= state_count) {
            return false;
        } else {
            if (state_id == Index) {
                using State = type_at_t<Index, state_list>;
                return defers_event<State, Event, deferred_list>::value;
            }
            return dispatch_defer_source_id<Event, Index + 1U>(state_id);
        }
    }
 
    template<typename Event>
    bool defer_event(Event const& event) {
        if constexpr (deferred_event_set::template contains<Event>()) {
            return deferred_queue<Event>().push(event);
        } else {
            return false;
        }
    }
 
    void recall_deferred_events() {
        if constexpr (deferred_event_count > 0U) {
            deferred_recall_scope recall{recalling_deferred_};
            recall_deferred_event_id<0U>();
        }
    }
 
    template<std::size_t Index>
    void recall_deferred_event_id() {
        if constexpr (Index < deferred_event_count) {
            using Event = type_at_t<Index, deferred_events>;
            Event event{};
            while (deferred_queue<Event>().pop(event)) {
                (void)handle(event);
            }
            recall_deferred_event_id<Index + 1U>();
        }
    }
 
    template<typename Event>
    [[nodiscard]] auto& deferred_queue() {
        return std::get<deferred_event_queue<Event, deferred_capacity>>(
          deferred_queues_);
    }
 
    template<typename Event>
    [[nodiscard]] auto const& deferred_queue() const {
        return std::get<deferred_event_queue<Event, deferred_capacity>>(
          deferred_queues_);
    }
 
    context_type context_;
    States states_{};
    std::uint16_t active_state_{};
    tsm::core::static_path<state_count> active_path_{};
    history_storage history_{};
    deferred_queues deferred_queues_{};
    bool recalling_deferred_{};
    [[no_unique_address]] logging_policy logger_{};
 
    struct deferred_recall_scope {
        explicit deferred_recall_scope(bool& flag) noexcept : flag_(flag) {
            flag_ = true;
        }
 
        deferred_recall_scope(deferred_recall_scope const&) = delete;
        deferred_recall_scope& operator=(deferred_recall_scope const&) = delete;
 
        ~deferred_recall_scope() noexcept { flag_ = false; }
 
      private:
        bool& flag_;
    };
};
 
template<typename T, typename = void>
struct make_hsm;
 
template<typename T>
struct make_hsm<T, std::enable_if_t<!is_state_trait_v<T>>> {
    using type = T;
};
 
template<typename T>
using make_hsm_t = typename make_hsm<T>::type;
 
template<typename T, bool IsTransition = transition_like<T>>
struct wrap_transition {
    using type = T;
};
 
template<typename T>
struct wrap_transition<T, true> {
    using from = typename T::from;
    using event = typename T::event;
    using to = typename T::to;
 
    using wrap_from =
      std::conditional_t<is_state_trait_v<from>, make_hsm_t<from>, from>;
    using wrap_to =
      std::conditional_t<is_state_trait_v<to>, make_hsm_t<to>, to>;
 
    using type =
      typename transition_traits<T>::template with_endpoints<wrap_from,
                                                             event,
                                                             wrap_to>;
};
 
template<typename T>
using wrap_transition_t = typename wrap_transition<T>::type;
 
template<typename... TransitionEntries>
struct wrap_transitions;
 
template<typename... TransitionEntries>
struct wrap_transitions<type_list<TransitionEntries...>> {
    using type = type_list<wrap_transition_t<TransitionEntries>...>;
};
 
template<typename T>
using wrap_transitions_t = typename wrap_transitions<as_type_list_t<T>>::type;
 
template<typename T>
struct synchronization_entries_of {
    using explicit_rules = typename synchronization_of<T>::type;
    using authored_rules =
      synchronization_entries_t<wrap_transitions_t<transitions_of_t<T>>>;
    using type = concat_type_lists_t<explicit_rules, authored_rules>;
};
 
template<typename T>
using synchronization_entries_of_t = typename synchronization_entries_of<T>::type;
 
template<typename T>
struct make_hsm<T, std::enable_if_t<is_state_trait_v<T>>> {
    using transitions = wrap_transitions_t<transitions_of_t<T>>;
 
    using type = hsm<T, transitions>;
};
 
template<typename Join, typename Rules>
struct join_to_rule_for;
 
template<typename Join>
struct join_to_rule_for<Join, type_list<>> {
    using type = void;
};
 
template<typename Join, typename First, typename... Rest>
struct join_to_rule_for<Join, type_list<First, Rest...>> {
    template<typename Rule>
    struct matching_join_to : std::false_type {};
 
    template<join_to_rule_like Rule>
    struct matching_join_to<Rule>
      : std::bool_constant<std::is_same_v<typename Rule::join, Join>> {};
 
    using candidate =
      std::conditional_t<matching_join_to<First>::value, First, void>;
    using type =
      std::conditional_t<std::is_void_v<candidate>,
                         typename join_to_rule_for<Join,
                                                   type_list<Rest...>>::type,
                         candidate>;
};
 
template<typename Join, typename Rules>
using join_to_rule_for_t = typename join_to_rule_for<Join, Rules>::type;
 
template<typename Join, typename Rules>
struct join_to_rule_count;
 
template<typename Join>
struct join_to_rule_count<Join, type_list<>> : std::integral_constant<std::size_t, 0U> {};
 
template<typename Join, typename First, typename... Rest>
struct join_to_rule_count<Join, type_list<First, Rest...>> {
    template<typename Rule>
    struct matching_join_to : std::false_type {};
 
    template<join_to_rule_like Rule>
    struct matching_join_to<Rule>
      : std::bool_constant<std::is_same_v<typename Rule::join, Join>> {};
 
    static constexpr std::size_t value =
      (matching_join_to<First>::value ? 1U : 0U) +
      join_to_rule_count<Join, type_list<Rest...>>::value;
};
 
template<typename... RegionDefinitions>
struct OrthogonalExecutionPolicy {
    static constexpr bool is_hsm = true;
    using type = OrthogonalExecutionPolicy<RegionDefinitions...>;
    using regions = type_list<RegionDefinitions...>;
    using synchronization_rules =
      concat_type_lists_t<synchronization_entries_of_t<RegionDefinitions>...>;
    using completion = completion_event;
    static constexpr std::size_t region_count = sizeof...(RegionDefinitions);
    static constexpr std::size_t synchronization_rule_count =
      tsm::core::type_set<synchronization_rules>::size;
    static_assert(synchronization_rule_count <= 64U,
                  "tsm: OrthogonalExecutionPolicy synchronization tracking "
                  "supports up to 64 synchronization rules");
    static_assert(region_count <= 64U,
                  "tsm: OrthogonalExecutionPolicy dispatch result stores "
                  "handled regions in a 64-bit mask");
 
    template<typename RegionDefinition>
    using region_hsm = hsm<RegionDefinition>;
 
    OrthogonalExecutionPolicy() {
        static_assert(validate_synchronization_rules(),
                      "tsm: synchronization rules must reference states owned "
                      "by one orthogonal region, and each join_from must have "
                      "exactly one matching join_to");
    }
 
    struct dispatch_result {
        std::uint64_t handled_mask{};
        std::uint64_t completion_handled_mask{};
        bool completed{};
        bool completion_dispatched{};
        bool synchronization_handled{};
 
        [[nodiscard]] constexpr bool handled() const {
            return handled_mask != 0U || synchronization_handled;
        }
 
        [[nodiscard]] constexpr bool completion_handled() const {
            return completion_handled_mask != 0U;
        }
 
        template<typename RegionDefinition>
        [[nodiscard]] constexpr bool region_handled() const {
            constexpr auto index = region_index<RegionDefinition>();
            return (handled_mask & bit(index)) != 0U;
        }
 
        template<typename RegionDefinition>
        [[nodiscard]] constexpr bool completion_region_handled() const {
            constexpr auto index = region_index<RegionDefinition>();
            return (completion_handled_mask & bit(index)) != 0U;
        }
 
        template<typename RegionDefinition>
        constexpr void mark_handled() {
            constexpr auto index = region_index<RegionDefinition>();
            handled_mask |= bit(index);
        }
 
        template<typename RegionDefinition>
        constexpr void mark_completion_handled() {
            constexpr auto index = region_index<RegionDefinition>();
            completion_handled_mask |= bit(index);
        }
    };
 
    template<typename RegionDefinition>
    [[nodiscard]] region_hsm<RegionDefinition>& region() {
        return std::get<region_hsm<RegionDefinition>>(regions_);
    }
 
    template<typename RegionDefinition>
    [[nodiscard]] region_hsm<RegionDefinition> const& region() const {
        return std::get<region_hsm<RegionDefinition>>(regions_);
    }
 
    template<typename Event>
    void enter(Event&& event) {
        auto& e = event;
        std::apply([&e](auto&... region_hsm) { (region_hsm.enter(e), ...); },
                   regions_);
    }
 
    template<typename Event>
    void leave(Event&& event) {
        auto& e = event;
        std::apply([&e](auto&... region_hsm) { (region_hsm.leave(e), ...); },
                   regions_);
    }
 
    template<typename Event>
    void entry(Event&& event) {
        enter(std::forward<Event>(event));
    }
 
    template<typename Event>
    void exit(Event&& event) {
        leave(std::forward<Event>(event));
    }
 
    template<typename Event>
    bool handle(Event&& event) {
        return dispatch(std::forward<Event>(event)).handled();
    }
 
    template<typename Event>
    dispatch_result dispatch(Event&& event) {
        auto& e = event;
        dispatch_result result{};
        dispatch_regions<0U>(result, e);
        process_synchronization(result);
        result.completed = complete();
        maybe_dispatch_completion<std::decay_t<Event>>(result);
        return result;
    }
 
    template<typename State>
    [[nodiscard]] bool active() const {
        bool result = false;
        std::apply(
          [&result](auto const&... region_hsm) {
              ((result = region_active<State>(region_hsm) || result), ...);
          },
          regions_);
        return result;
    }
 
    template<typename ForkRule>
    void fork() {
        activate_fork_targets<ForkRule>();
    }
 
    template<typename ForkRule>
    void activate_fork_targets() {
        static_assert(fork_rule_like<ForkRule>,
                      "tsm: fork requires tsm::fork_to<Fork, Targets...>");
        activate_targets(typename ForkRule::targets{});
    }
 
    template<typename JoinFromRule>
    [[nodiscard]] bool join_enabled() const {
        static_assert(
          join_from_rule_like<JoinFromRule>,
          "tsm: join_enabled requires tsm::join_from<Join, Sources...>");
        return sources_active(typename JoinFromRule::sources{});
    }
 
    template<typename JoinFromRule, typename JoinToRule>
    bool join() {
        static_assert(
          join_from_rule_like<JoinFromRule>,
          "tsm: join requires tsm::join_from<Join, Sources...>");
        static_assert(join_to_rule_like<JoinToRule>,
                      "tsm: join requires tsm::join_to<Join, Target>");
        static_assert(std::is_same_v<typename JoinFromRule::join,
                                     typename JoinToRule::join>,
                      "tsm: join_from and join_to must name the same join");
        if (!join_enabled<JoinFromRule>()) {
            return false;
        }
        activate_target<typename JoinToRule::target>();
        return true;
    }
 
    template<typename RegionDefinition>
    [[nodiscard]] bool region_complete() const {
        return region<RegionDefinition>()
          .template active_final<RegionDefinition>();
    }
 
    [[nodiscard]] bool complete() const {
        if constexpr (sizeof...(RegionDefinitions) == 0U) {
            return true;
        } else {
            return (region_complete<RegionDefinitions>() && ...);
        }
    }
 
    template<typename Event = completion_event>
    dispatch_result dispatch_completion_if_complete() {
        if (!complete()) {
            return {};
        }
        Event event{};
        dispatch_result result{};
        dispatch_completion_regions<0U>(result, event);
        result.completed = complete();
        result.completion_dispatched = true;
        completion_dispatched_ = true;
        return result;
    }
 
    template<typename State>
    static consteval bool state_in_regions() {
        return (region_hsm<RegionDefinitions>::runtime_state_set::template contains<State>() ||
                ...);
    }
 
    template<typename... States>
    static consteval bool states_in_regions(type_list<States...>) {
        return (state_in_regions<States>() && ...);
    }
 
    template<typename Rule>
    static consteval bool valid_synchronization_rule() {
        if constexpr (fork_rule_like<Rule>) {
            return states_in_regions(typename Rule::targets{});
        } else if constexpr (join_from_rule_like<Rule>) {
            return states_in_regions(typename Rule::sources{}) &&
                   join_to_rule_count<typename Rule::join,
                                      synchronization_rules>::value == 1U;
        } else if constexpr (join_to_rule_like<Rule>) {
            return state_in_regions<typename Rule::target>();
        } else {
            return false;
        }
    }
 
    template<typename... Rules>
    static consteval bool validate_synchronization_rules(type_list<Rules...>) {
        return (valid_synchronization_rule<Rules>() && ...);
    }
 
    static consteval bool validate_synchronization_rules() {
        return validate_synchronization_rules(synchronization_rules{});
    }
 
    template<typename RegionDefinition>
    static consteval std::uint16_t region_index() {
        return tsm::core::type_set<regions>::template index<RegionDefinition>();
    }
 
    static constexpr std::uint64_t bit(std::uint16_t index) {
        return std::uint64_t{ 1U } << index;
    }
 
    template<std::size_t Index, typename Event>
    void dispatch_regions(dispatch_result& result, Event& event) {
        if constexpr (Index < region_count) {
            using RegionDefinition = type_at_t<Index, regions>;
            if (region<RegionDefinition>().handle(event)) {
                result.template mark_handled<RegionDefinition>();
            }
            dispatch_regions<Index + 1U>(result, event);
        }
    }
 
    void process_synchronization(dispatch_result& result) {
        if constexpr (!empty_type_list_v<synchronization_rules>) {
            result.synchronization_handled =
              process_fork_rules<0U>() || result.synchronization_handled;
            result.synchronization_handled =
              process_join_rules<0U>() || result.synchronization_handled;
        }
    }
 
    template<std::size_t Index>
    bool process_fork_rules() {
        if constexpr (Index >= synchronization_rule_count) {
            return false;
        } else {
            using Rule = type_at_t<Index, synchronization_rules>;
            bool handled = false;
            if constexpr (fork_rule_like<Rule>) {
                constexpr auto mask = bit(Index);
                if (active<typename Rule::fork>()) {
                    if ((synchronization_fork_mask_ & mask) == 0U) {
                        activate_fork_targets<Rule>();
                        synchronization_fork_mask_ |= mask;
                        handled = true;
                    }
                } else {
                    synchronization_fork_mask_ &= ~mask;
                }
            }
            return process_fork_rules<Index + 1U>() || handled;
        }
    }
 
    template<std::size_t Index>
    bool process_join_rules() {
        if constexpr (Index >= synchronization_rule_count) {
            return false;
        } else {
            using Rule = type_at_t<Index, synchronization_rules>;
            bool handled = false;
            if constexpr (join_from_rule_like<Rule>) {
                constexpr auto mask = bit(Index);
                using JoinTo =
                  join_to_rule_for_t<typename Rule::join, synchronization_rules>;
                static_assert(!std::is_void_v<JoinTo>,
                              "tsm: join_from requires a matching join_to");
                if (join_enabled<Rule>()) {
                    if ((synchronization_join_mask_ & mask) == 0U) {
                        handled = join<Rule, JoinTo>();
                        synchronization_join_mask_ |= mask;
                    }
                } else {
                    synchronization_join_mask_ &= ~mask;
                }
            }
            return process_join_rules<Index + 1U>() || handled;
        }
    }
 
    template<typename Event>
    void maybe_dispatch_completion(dispatch_result& result) {
        if constexpr (!std::is_same_v<Event, completion_event>) {
            if (result.completed && !completion_dispatched_) {
                completion_event event{};
                dispatch_completion_regions<0U>(result, event);
                result.completion_dispatched = true;
                completion_dispatched_ = true;
            } else if (!result.completed) {
                completion_dispatched_ = false;
            }
        }
    }
 
    template<std::size_t Index, typename Event>
    void dispatch_completion_regions(dispatch_result& result, Event& event) {
        if constexpr (Index < region_count) {
            using RegionDefinition = type_at_t<Index, regions>;
            if (region<RegionDefinition>().handle(event)) {
                result.template mark_completion_handled<RegionDefinition>();
            }
            dispatch_completion_regions<Index + 1U>(result, event);
        }
    }
 
    template<typename State, typename RegionHsm>
    static bool region_active(RegionHsm const& region_hsm) {
        if constexpr (RegionHsm::runtime_state_set::template contains<State>()) {
            return region_hsm.template active<State>();
        } else {
            return false;
        }
    }
 
    template<typename... Targets>
    void activate_targets(type_list<Targets...>) {
        (activate_target<Targets>(), ...);
    }
 
    template<typename Target>
    void activate_target() {
        std::apply(
          [](auto&... region_hsm) {
              (activate_region_target<Target>(region_hsm), ...);
          },
          regions_);
    }
 
    template<typename Target, typename RegionHsm>
    static void activate_region_target(RegionHsm& region_hsm) {
        if constexpr (RegionHsm::runtime_state_set::template contains<Target>()) {
            region_hsm.template current_state<Target>();
            region_hsm.template resolve_decision_pseudostate<Target>();
        }
    }
 
    template<typename... Sources>
    [[nodiscard]] bool sources_active(type_list<Sources...>) const {
        return (active<Sources>() && ...);
    }
 
    std::tuple<region_hsm<RegionDefinitions>...> regions_{};
    std::uint64_t synchronization_fork_mask_{};
    std::uint64_t synchronization_join_mask_{};
    bool completion_dispatched_{};
};
 
template<typename HsmType, typename Events>
class erased_event;
 
template<typename HsmType, typename = void>
struct get_events_from_hsm;
 
template<typename Transition>
struct get_events_from_transition;
 
template<typename TransitionList>
struct aggregate_events;
 
template<typename... TransitionEntries>
struct aggregate_events<type_list<TransitionEntries...>> {
    using type = decltype(std::tuple_cat(
      typename get_events_from_transition<TransitionEntries>::type{}...));
};
 
template<>
struct aggregate_events<type_list<>> {
    using type = std::tuple<>;
};
 
template<typename Transition>
struct get_events_from_transition {
    using Event = std::tuple<typename Transition::event>;
    using FromEvents =
      typename get_events_from_hsm<typename Transition::from>::type;
    using ToEvents =
      typename get_events_from_hsm<typename Transition::to>::type;
    using type = decltype(std::tuple_cat(Event{}, FromEvents{}, ToEvents{}));
};
 
template<typename HsmType>
struct get_events_from_hsm<HsmType,
                           std::enable_if_t<has_transitions_v<HsmType>>> {
    using transition_list = as_type_list_t<typename HsmType::transitions>;
    using type = typename aggregate_events<transition_list>::type;
};
 
template<typename HsmType>
struct get_events_from_hsm<HsmType,
                           std::enable_if_t<!has_transitions_v<HsmType>>> {
    using type = std::tuple<>;
};
 
template<typename HsmType>
using get_events_t =
  unique_tuple_t<typename get_events_from_hsm<HsmType>::type>;
 
template<typename HsmType, typename Events>
class erased_event {
    using event_list = as_type_list_t<Events>;
 
  public:
    static constexpr std::size_t storage_size = max_sizeof(event_list{});
    static constexpr std::size_t storage_alignment = max_alignof(event_list{});
 
    erased_event() = default;
 
    template<typename Event>
        requires (contains_type<std::decay_t<Event>>(event_list{}))
    explicit erased_event(Event&& event) {
        emplace<std::decay_t<Event>>(std::forward<Event>(event));
    }
 
    erased_event(erased_event const& other) { copy_from(other); }
 
    erased_event(erased_event&& other) noexcept { move_from(other); }
 
    // cppcheck-suppress operatorEqVarError
    erased_event& operator=(erased_event const& other) {
        if (this != &other) {
            reset();
            copy_from(other);
        }
        return *this;
    }
 
    // cppcheck-suppress operatorEqVarError
    erased_event& operator=(erased_event&& other) noexcept {
        if (this != &other) {
            reset();
            move_from(other);
        }
        return *this;
    }
 
    ~erased_event() { reset(); }
 
    [[nodiscard]] bool empty() const { return dispatch_ == nullptr; }
 
    bool dispatch(HsmType& hsm) {
        if (dispatch_ == nullptr) {
            return false;
        }
        return dispatch_(hsm, data());
    }
 
  private:
    using dispatch_fn = bool (*)(HsmType&, void*);
    using copy_fn = void (*)(void*, void const*);
    using move_fn = void (*)(void*, void*);
    using destroy_fn = void (*)(void*);
 
    template<typename Event, typename... Args>
    void emplace(Args&&... args) {
        static_assert(sizeof(Event) <= storage_size);
        static_assert(alignof(Event) <= storage_alignment);
 
        new (data()) Event(std::forward<Args>(args)...);
        dispatch_ = [](HsmType& hsm, void* storage) -> bool {
            return hsm.handle(*static_cast<Event*>(storage));
        };
        copy_ = [](void* destination, void const* source) {
            new (destination) Event(*static_cast<Event const*>(source));
        };
        move_ = [](void* destination, void* source) {
            new (destination) Event(std::move(*static_cast<Event*>(source)));
        };
        destroy_ = [](void* storage) {
            static_cast<Event*>(storage)->~Event();
        };
    }
 
    void copy_from(erased_event const& other) {
        if (other.copy_ == nullptr) {
            return;
        }
        other.copy_(data(), other.data());
        dispatch_ = other.dispatch_;
        copy_ = other.copy_;
        move_ = other.move_;
        destroy_ = other.destroy_;
    }
 
    void move_from(erased_event& other) {
        if (other.move_ == nullptr) {
            return;
        }
        other.move_(data(), other.data());
        dispatch_ = other.dispatch_;
        copy_ = other.copy_;
        move_ = other.move_;
        destroy_ = other.destroy_;
        other.reset();
    }
 
    void reset() {
        if (destroy_ != nullptr) {
            destroy_(data());
        }
        dispatch_ = nullptr;
        copy_ = nullptr;
        move_ = nullptr;
        destroy_ = nullptr;
    }
 
    void* data() { return storage_; }
    void const* data() const { return storage_; }
 
    alignas(storage_alignment) unsigned char storage_[storage_size]{};
    dispatch_fn dispatch_{};
    copy_fn copy_{};
    move_fn move_{};
    destroy_fn destroy_{};
};
 
template<typename HsmType, std::size_t Capacity>
class tick_scheduler {
  public:
    using events = get_events_t<HsmType>;
    using event_type = erased_event<HsmType, events>;
 
    static_assert(Capacity > 0U,
                  "tsm: tick_scheduler requires at least one timer slot");
 
    template<typename Event>
        requires (contains_type<std::decay_t<Event>>(as_type_list_t<events>{}))
    [[nodiscard]] bool after_ticks(Event&& event, tsm::tick_rep ticks) {
        return schedule(std::forward<Event>(event), ticks, 0U, false);
    }
 
    template<typename Event>
        requires (contains_type<std::decay_t<Event>>(as_type_list_t<events>{}))
    [[nodiscard]] bool after_ticks(Event&& event, tsm::tick_count ticks) {
        return after_ticks(std::forward<Event>(event), ticks.count());
    }
 
    template<typename Event>
        requires (contains_type<std::decay_t<Event>>(as_type_list_t<events>{}))
    [[nodiscard]] bool every_ticks(Event&& event, tsm::tick_rep period) {
        return period != 0U &&
               schedule(std::forward<Event>(event), period, period, true);
    }
 
    template<typename Event>
        requires (contains_type<std::decay_t<Event>>(as_type_list_t<events>{}))
    [[nodiscard]] bool every_ticks(Event&& event, tsm::tick_count period) {
        return every_ticks(std::forward<Event>(event), period.count());
    }
 
    [[nodiscard]] std::size_t pending() const {
        std::size_t count{};
        for (auto const& timer : timers_) {
            if (timer.active) {
                // cppcheck-suppress useStlAlgorithm
                ++count;
            }
        }
        return count;
    }
 
    [[nodiscard]] bool empty() const { return pending() == 0U; }
 
    std::size_t tick(HsmType& hsm, tsm::tick_rep elapsed_ticks = 1U) {
        std::size_t dispatched{};
        tsm::tick_rep remaining_elapsed = elapsed_ticks;
 
        while (remaining_elapsed > 0U) {
            const tsm::tick_rep step = next_step(remaining_elapsed);
            advance(step);
            remaining_elapsed -= step;
            dispatched += dispatch_due(hsm);
        }
        return dispatched;
    }
 
    std::size_t tick(HsmType& hsm, tsm::tick_count elapsed_ticks) {
        return tick(hsm, elapsed_ticks.count());
    }
 
    void clear() {
        for (auto& timer : timers_) {
            // cppcheck-suppress useStlAlgorithm
            timer = timer_slot{};
        }
    }
 
  private:
    struct timer_slot {
        event_type event{};
        tsm::tick_rep remaining{};
        tsm::tick_rep period{};
        bool periodic{};
        bool active{};
    };
 
    template<typename Event>
    [[nodiscard]] bool schedule(Event&& event,
                                tsm::tick_rep ticks,
                                tsm::tick_rep period,
                                bool periodic) {
        for (auto& timer : timers_) {
            // cppcheck-suppress useStlAlgorithm
            if (!timer.active) {
                timer.event = event_type(std::forward<Event>(event));
                timer.remaining = ticks;
                timer.period = period;
                timer.periodic = periodic;
                timer.active = true;
                return true;
            }
        }
        return false;
    }
 
    [[nodiscard]] tsm::tick_rep next_step(tsm::tick_rep elapsed_limit) const {
        tsm::tick_rep step = elapsed_limit;
        for (auto const& timer : timers_) {
            if (!timer.active) {
                continue;
            }
            if (timer.remaining == 0U) {
                return 1U;
            }
            if (timer.remaining < step) {
                step = timer.remaining;
            }
        }
        return step;
    }
 
    void advance(tsm::tick_rep ticks) {
        for (auto& timer : timers_) {
            if (!timer.active) {
                continue;
            }
            if (timer.remaining > ticks) {
                timer.remaining -= ticks;
            } else {
                timer.remaining = 0U;
            }
        }
    }
 
    std::size_t dispatch_due(HsmType& hsm) {
        std::size_t dispatched{};
        for (auto& timer : timers_) {
            if (!timer.active) {
                continue;
            }
            if (timer.remaining == 0U) {
                auto event = timer.periodic ? timer.event : std::move(timer.event);
                (void)event.dispatch(hsm);
                ++dispatched;
                if (timer.periodic) {
                    timer.remaining = timer.period;
                } else {
                    timer = timer_slot{};
                }
            }
        }
        return dispatched;
    }
 
    std::array<timer_slot, Capacity> timers_{};
};
 
template<typename HsmType, std::size_t Capacity>
using TickScheduler = tick_scheduler<HsmType, Capacity>;
 
} // namespace detail
 
#if defined(__linux__) && !defined(__QNXNTO__) && !defined(__ZEPHYR__) &&      \
  !defined(TSM_SUPPRESS_AUTO_PLATFORM_ADAPTERS)
} // namespace tsm
#include "tsm/linux.h"
namespace tsm {
#endif
 
using detail::action;
using detail::automatic_event;
using detail::choice;
using detail::ClockedTransition;
using detail::ClockTickEvent;
using detail::completion_event;
using detail::deep_history_state;
using detail::defer;
using detail::edge;
using detail::Event;
using detail::External;
using detail::final_state;
using detail::fork;
using detail::Fork;
using detail::fork_to;
using detail::guard;
using detail::history_state;
using detail::hsm;
using detail::Internal;
using detail::internal;
using detail::join;
using detail::Join;
using detail::join_from;
using detail::join_to;
using detail::JoinTo;
using detail::junction;
using detail::local;
using detail::make_hsm_t;
using detail::on;
using detail::OrthogonalExecutionPolicy;
using detail::region;
using detail::T;
using detail::tick_scheduler;
using detail::TickScheduler;
using detail::transition_kind;
using detail::type_list;
using detail::with_action;
using detail::with_guard;
using detail::with_guard_action;
 
#if defined(__linux__) && !defined(__QNXNTO__) && !defined(__ZEPHYR__) &&      \
  !defined(TSM_SUPPRESS_AUTO_PLATFORM_ADAPTERS)
template<typename... Tasks>
using thread_executor = detail::thread_executor<Tasks...>;
template<typename... Tasks>
using realtime_thread_executor = detail::realtime_thread_executor<Tasks...>;
template<typename... Tasks>
using task_executor = detail::task_executor<Tasks...>;
#endif
 
template<typename... Deferred>
using deferred_events = detail::type_list<Deferred...>;
 
template<typename... Rules>
using synchronization = detail::type_list<Rules...>;
 
template<typename... TransitionEntries>
using transition_table = detail::type_list<TransitionEntries...>;
 
template<typename... TransitionEntries>
using Ts = transition_table<TransitionEntries...>;
 
template<detail::transition_like... TransitionEntries>
consteval auto transitions(TransitionEntries...) {
    return Ts<TransitionEntries...>{};
}
 
#define TSM_TRANSITION(Name, From, Event, To)                                  \
    struct Name {                                                             \
        using from = From;                                                    \
        using event = Event;                                                  \
        using to = To;                                                        \
    }
 
#define TSM_TRANSITION_ACTION(Name, From, Event, To, Action)                  \
    struct Name {                                                             \
        using from = From;                                                    \
        using event = Event;                                                  \
        using to = To;                                                        \
        static constexpr auto action = Action;                                \
    }
 
#define TSM_TRANSITION_GUARD(Name, From, Event, To, Guard)                    \
    struct Name {                                                             \
        using from = From;                                                    \
        using event = Event;                                                  \
        using to = To;                                                        \
        static constexpr auto guard = Guard;                                  \
    }
 
#define TSM_TRANSITION_GUARD_ACTION(Name, From, Event, To, Guard, Action)     \
    struct Name {                                                             \
        using from = From;                                                    \
        using event = Event;                                                  \
        using to = To;                                                        \
        static constexpr auto guard = Guard;                                  \
        static constexpr auto action = Action;                                \
    }
 
#define TSM_TRANSITIONS(...) using transitions = ::tsm::Ts<__VA_ARGS__>
 
} // namespace tsm
 
#if defined(__FREE_RTOS__)
#include "tsm/freertos.h"
#endif
#include "tsm/runtime.h"
#if defined(__QNXNTO__)
#include "tsm/qnx.h"
#endif
 
#if defined(TSM_ENABLE_REFLECTION) && TSM_ENABLE_REFLECTION
#include "tsm/reflection.h"
#endif