diff --git a/include/boost/sml.hpp b/include/boost/sml.hpp
index e974c0f3..737308cd 100644
--- a/include/boost/sml.hpp
+++ b/include/boost/sml.hpp
@@ -763,6 +763,10 @@ template <class R, class T, int N>
 constexpr R get_id(type_id_type<N, T> *) {
   return static_cast<R>(N);
 }
+template <class T, int N>
+constexpr true_type has_type_id(type_id_type<N, T> *);
+template <class T>
+constexpr false_type has_type_id(...);
 template <template <class...> class, class T>
 struct is : false_type {};
 template <template <class...> class T, class... Ts>
@@ -1299,6 +1303,15 @@ struct transitions<aux::false_type> {
     return false;
   }
 };
+template <class TEvent, class...>
+struct has_terminate_parent_transition : aux::false_type {};
+template <class TEvent, class TTransition, class... TRest>
+struct has_terminate_parent_transition<TEvent, TTransition, TRest...>
+    : aux::conditional<
+          aux::is_same<terminate_state, typename TTransition::dst_state>::value &&
+              aux::is_same<TEvent, typename TTransition::event>::value,
+          aux::true_type,
+          has_terminate_parent_transition<TEvent, TRest...>>::type {};
 template <class Tsm, class T, class... Ts>
 struct transitions_sub<sm<Tsm>, T, Ts...> {
   template <class TEvent, class SM, class TDeps, class TSubs>
@@ -1314,7 +1327,14 @@ struct transitions_sub<sm<Tsm>, T, Ts...> {
   }
   template <class TEvent, class SM, class TDeps, class TSubs>
   constexpr static bool execute_impl(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
-    const auto handled = sub_sm<sm_impl<Tsm>>::get(&subs).process_event(event, deps, subs);
+    auto &sub = sub_sm<sm_impl<Tsm>>::get(&subs);
+    const auto handled = sub.process_event(event, deps, subs);
+
+    if (handled && sub.is_terminated() && has_terminate_parent_transition<TEvent, T, Ts...>::value) {
+      const auto propagated = transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+      return propagated ? propagated : handled;
+    }
+
     return handled ? handled : transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
   }
   template <class _, class TEvent, class SM, class TDeps, class TSubs>
@@ -2088,12 +2108,17 @@ struct sm_impl : aux::conditional_t<aux::should_not_subclass_statemachine_class<
   constexpr static void visit_state(const TVisitor &visitor) {
     visitor(aux::string<TState>{});
   }
-  constexpr bool is_terminated() const { return is_terminated_impl(aux::make_index_sequence<regions>{}); }
-  constexpr bool is_terminated_impl(aux::index_sequence<0>) const {
-    return current_state_[0] == aux::get_id<state_t, terminate_state>((states_ids_t *)0);
+  constexpr bool is_terminated() const {
+    return is_terminated_impl(aux::make_index_sequence<regions>{},
+                              decltype(aux::has_type_id<terminate_state>((states_ids_t *)0)){});
+  }
+  template <int... Ns>
+  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>, aux::false_type) const {
+    (void)sizeof...(Ns);
+    return false;
   }
   template <int... Ns>
-  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>) const {
+  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>, aux::true_type) const {
 #if defined(__cpp_fold_expressions)
     return ((current_state_[Ns] == aux::get_id<state_t, terminate_state>((states_ids_t *)0)) && ...);
 #else
diff --git a/include/boost/sml/utility/dispatch_table.hpp b/include/boost/sml/utility/dispatch_table.hpp
index 9bd35f3a..bcac3277 100644
--- a/include/boost/sml/utility/dispatch_table.hpp
+++ b/include/boost/sml/utility/dispatch_table.hpp
@@ -101,7 +101,14 @@ auto make_dispatch_table(SM &fsm, const aux::index_sequence<Ns...> &) {
     using dispatch_table_t = bool (*)(SM &, const TEvent &);
     const static dispatch_table_t dispatch_table[sizeof...(Ns) ? sizeof...(Ns) : 1] = {
         &get_event_t<Ns + EventRangeBegin, events_ids_t>::template execute<SM, TEvent>...};
-    return dispatch_table[id - EventRangeBegin](fsm, e);
+    const auto id64 = static_cast<long long>(id);
+    const auto begin64 = static_cast<long long>(EventRangeBegin);
+    const auto count64 = static_cast<long long>(sizeof...(Ns));
+    if (id64 < begin64 || id64 >= begin64 + count64) {
+      return false;
+    }
+    const auto dispatch_id = static_cast<int>(id64 - begin64);
+    return dispatch_table[dispatch_id](fsm, e);
   };
 }
 }  // namespace detail
diff --git a/scripts/quality_gates.sh b/scripts/quality_gates.sh
index f6f4cf77..118e1cab 100755
--- a/scripts/quality_gates.sh
+++ b/scripts/quality_gates.sh
@@ -527,6 +527,9 @@ fi
 if [[ -n "${EXTRA_CXX_FLAGS}" ]]; then
   BASE_CXX_FLAGS="${BASE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}"
 fi
+if [[ "${COMPILER_FAMILY}" == "clang" ]]; then
+  BASE_CXX_FLAGS="${BASE_CXX_FLAGS} -Wno-unknown-warning-option -Wno-error=mismatched-tags -Wno-error=stack-exhausted -Wno-stack-exhausted"
+fi
 
 require_defaults
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b99c9452..7b5945ba 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -18,5 +18,9 @@ elseif(IS_COMPILER_OPTION_GCC_LIKE)
   add_compile_options(-include common/test.hpp)
 endif()
 
+if(MINGW AND IS_COMPILER_OPTION_GCC_LIKE)
+  add_compile_options(-Wa,-mbig-obj)
+endif()
+
 add_subdirectory(ft)
 add_subdirectory(ut)
diff --git a/test/ft/CMakeLists.txt b/test/ft/CMakeLists.txt
index 267a0c89..58e118a2 100644
--- a/test/ft/CMakeLists.txt
+++ b/test/ft/CMakeLists.txt
@@ -63,6 +63,12 @@ add_test(test_policies_testing test_policies_testing)
 add_executable(test_policies_dispatch policies_dispatch.cpp)
 add_test(test_policies_dispatch test_policies_dispatch)
 
+add_executable(test_extended_tests extended_tests.cpp)
+add_test(test_extended_tests test_extended_tests)
+
+add_executable(test_issues_test issues_test.cpp)
+add_test(test_issues_test test_issues_test)
+
 add_executable(test_policies_thread_safe policies_thread_safe.cpp)
 add_test(test_policies_thread_safe test_policies_thread_safe)
 target_link_libraries(test_policies_thread_safe -lpthread)
diff --git a/test/ft/extended_tests.cpp b/test/ft/extended_tests.cpp
new file mode 100644
index 00000000..3899258a
--- /dev/null
+++ b/test/ft/extended_tests.cpp
@@ -0,0 +1,198 @@
+#include <algorithm>
+#include <boost/sml.hpp>
+#include <string>
+#include <vector>
+
+namespace sml = boost::sml;
+
+inline std::string canonical_state_name(std::string state) {
+  if (0 == state.find("class ")) {
+    state.erase(0, 6);
+  } else if (0 == state.find("struct ")) {
+    state.erase(0, 7);
+  }
+  const auto scope_pos = state.rfind("::");
+  if (scope_pos != std::string::npos) {
+    state.erase(0, scope_pos + 2);
+  }
+  return state;
+}
+
+template <class TSM>
+std::vector<std::string> sorted_current_states(const TSM& sm) {
+  std::vector<std::string> states;
+  sm.visit_current_states([&](auto state) { states.push_back(canonical_state_name(state.c_str())); });
+  std::sort(states.begin(), states.end());
+  return states;
+}
+
+template <class TSM>
+bool all_regions_terminated(const TSM& sm) {
+  const auto states = sorted_current_states(sm);
+  return std::all_of(states.cbegin(), states.cend(), [](const auto& state) { return state == "terminate"; });
+}
+
+struct e_single_start {};
+struct e_single_finish {};
+struct e_single_idle {};
+
+struct e_ortho_left_start {};
+struct e_ortho_left_finish {};
+struct e_ortho_right_start {};
+struct e_ortho_right_finish {};
+struct e_ortho_unused {};
+struct e_ortho_right_done {};
+
+const auto qa_idle = sml::state<class qa_idle>;
+const auto qa_active = sml::state<class qa_active>;
+const auto qb_idle = sml::state<class qb_idle>;
+const auto qb_active = sml::state<class qb_active>;
+
+const auto qb_region_left = sml::state<class qb_region_left>;
+const auto qb_region_right = sml::state<class qb_region_right>;
+const auto qb_region_left_next = sml::state<class qb_region_left_next>;
+const auto qb_region_right_next = sml::state<class qb_region_right_next>;
+const auto qb_region_right_done = sml::state<class qb_region_right_done>;
+
+struct e_return_left {};
+struct e_return_right {};
+struct e_return_unused {};
+
+test is_single_region_termination_and_event_visibility = [] {
+  struct machine {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+          *qa_idle + event<e_single_start> = qa_active
+        , qa_active + event<e_single_finish> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<machine> sm{};
+  expect((std::vector<std::string>{"qa_idle"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_single_start{}));
+  expect((std::vector<std::string>{"qa_active"} == sorted_current_states(sm)));
+  expect(!sm.process_event(e_single_idle{}));
+  expect(sm.process_event(e_single_finish{}));
+  expect((std::vector<std::string>{"terminate"} == sorted_current_states(sm)));
+  expect(sm.is(sml::X));
+  expect(!sm.process_event(e_single_idle{}));
+};
+
+test orthogonal_regions_partial_termination = [] {
+  struct machine {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+         *qb_region_left  + event<e_ortho_left_start>  = qb_region_left_next
+        , qb_region_left_next + event<e_ortho_left_finish> = sml::X
+        , *qb_region_right + event<e_ortho_right_start>  = qb_region_right_next
+        , qb_region_right_next + event<e_ortho_right_finish> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<machine> sm{};
+  expect((std::vector<std::string>{"qb_region_left", "qb_region_right"} == sorted_current_states(sm)));
+  expect(!all_regions_terminated(sm));
+
+  expect(sm.process_event(e_ortho_left_start{}));
+  expect((std::vector<std::string>{"qb_region_left_next", "qb_region_right"} == sorted_current_states(sm)));
+  expect(!all_regions_terminated(sm));
+
+  expect(sm.process_event(e_ortho_left_finish{}));
+  expect((std::vector<std::string>{"qb_region_right", "terminate"} == sorted_current_states(sm)));
+  expect(!all_regions_terminated(sm));
+  expect(!sm.process_event(e_ortho_unused{}));
+  expect(!all_regions_terminated(sm));
+
+  expect(sm.process_event(e_ortho_right_start{}));
+  expect((std::vector<std::string>{"qb_region_right_next", "terminate"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_ortho_right_finish{}));
+  expect((std::vector<std::string>{"terminate", "terminate"} == sorted_current_states(sm)));
+  expect(all_regions_terminated(sm));
+};
+
+test visit_current_states_reports_all_regions = [] {
+  struct machine {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+         *qb_region_left + event<e_ortho_left_start> = qb_region_left_next
+        , qb_region_left_next + event<e_ortho_left_finish> = sml::X
+        , *qb_region_right + event<e_ortho_right_start> = qb_region_right_next
+        , qb_region_right_next + event<e_ortho_right_finish> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<machine> sm{};
+
+  expect((std::vector<std::string>{"qb_region_left", "qb_region_right"} == sorted_current_states(sm)));
+  sm.process_event(e_ortho_left_start{});
+  sm.process_event(e_ortho_right_start{});
+  expect((std::vector<std::string>{"qb_region_left_next", "qb_region_right_next"} == sorted_current_states(sm)));
+
+  sm.process_event(e_ortho_left_finish{});
+  sm.process_event(e_ortho_right_finish{});
+  expect((std::vector<std::string>{"terminate", "terminate"} == sorted_current_states(sm)));
+};
+
+test process_event_return_value_in_orthogonal_regions = [] {
+  struct machine {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+          *qa_idle + event<e_return_left> = qa_active
+        , qa_active + event<e_return_left> = qa_active
+        , *qb_idle + event<e_return_right> = qb_active
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<machine> sm{};
+  expect(sm.process_event(e_return_left{}));
+  expect((std::vector<std::string>{"qa_active", "qb_idle"} == sorted_current_states(sm)));
+  expect(!sm.process_event(e_return_unused{}));
+  expect((std::vector<std::string>{"qa_active", "qb_idle"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_return_right{}));
+  expect((std::vector<std::string>{"qa_active", "qb_active"} == sorted_current_states(sm)));
+};
+
+test orthogonal_regions_still_process_after_partial_termination = [] {
+  struct machine {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+         *qb_region_left + event<e_ortho_left_start> = qb_region_left_next
+        , qb_region_left_next + event<e_ortho_left_finish> = sml::X
+        , *qb_region_right + event<e_ortho_right_start> = qb_region_right_next
+        , qb_region_right_next + event<e_ortho_right_done> = qb_region_right_done
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<machine> sm{};
+  expect((std::vector<std::string>{"qb_region_left", "qb_region_right"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_ortho_left_start{}));
+  expect((std::vector<std::string>{"qb_region_left_next", "qb_region_right"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_ortho_left_finish{}));
+  expect((std::vector<std::string>{"qb_region_right", "terminate"} == sorted_current_states(sm)));
+
+  expect(sm.process_event(e_ortho_right_start{}));
+  expect((std::vector<std::string>{"qb_region_right_next", "terminate"} == sorted_current_states(sm)));
+  expect(sm.process_event(e_ortho_right_done{}));
+  expect((std::vector<std::string>{"qb_region_right_done", "terminate"} == sorted_current_states(sm)));
+  expect(!sm.process_event(e_ortho_unused{}));
+};
diff --git a/test/ft/issues_test.cpp b/test/ft/issues_test.cpp
new file mode 100644
index 00000000..547d1efc
--- /dev/null
+++ b/test/ft/issues_test.cpp
@@ -0,0 +1,4504 @@
+#include <atomic>
+#include <boost/sml.hpp>
+#include <chrono>
+#include <cstdio>
+#include <deque>
+#include <fstream>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <type_traits>
+#if !defined(_MSC_VER)
+#include <boost/sml/utility/dispatch_table.hpp>
+#endif
+
+namespace sml = boost::sml;
+
+namespace {
+const auto issue_88_state1 = sml::state<class issue_88_state1>;
+const auto issue_88_state2 = sml::state<class issue_88_state2>;
+const auto issue_86_state1 = sml::state<class issue_86_state1>;
+const auto issue_86_state2 = sml::state<class issue_86_state2>;
+const auto issue_85_state1 = sml::state<class issue_85_state1>;
+const auto issue_85_state2 = sml::state<class issue_85_state2>;
+const auto issue_85_state_other = sml::state<class issue_85_state_other>;
+const auto issue_93_state = sml::state<class issue_93_state>;
+const auto issue_98_s1 = sml::state<class issue_98_state_s1>;
+const auto issue_98_s2 = sml::state<class issue_98_state_s2>;
+const auto issue_98_s3 = sml::state<class issue_98_state_s3>;
+const auto issue_98_s4 = sml::state<class issue_98_state_s4>;
+[[maybe_unused]] const auto issue_313_state_start = sml::state<class issue_313_state_start>;
+[[maybe_unused]] const auto issue_313_state_mid = sml::state<class issue_313_state_mid>;
+[[maybe_unused]] const auto issue_313_state_terminal = sml::state<class issue_313_state_terminal>;
+
+[[maybe_unused]] inline bool issue_repro(const char* issue_path, int id, const char* title) {
+  std::printf("Reproducing issue #%d: %s\n", id, title);
+  std::printf("Refer to: %s\n", issue_path);
+
+  std::ifstream issue_file{issue_path};
+  if (!issue_file.is_open()) {
+    std::printf("Missing issue file: %s\n", issue_path);
+    return false;
+  }
+
+  std::string line;
+  std::getline(issue_file, line);
+  std::printf("Title from file: %s\n", line.c_str());
+  std::printf("Expected behavior from issue claim still unimplemented.\n");
+  return false;
+}
+
+struct issue_93_property {
+  int method_calls = 0;
+  void on_entry() { ++method_calls; }
+};
+
+struct issue_93_with_prop;
+
+struct issue_93_entry_action {
+  void operator()(issue_93_with_prop& owner) const;
+};
+
+struct issue_313_payload {
+  int value;
+};
+
+struct issue_313_traits {
+  static const std::function<bool(const issue_313_payload&)> is_below_five;
+  static const std::function<bool(const issue_313_payload&)> is_above_five;
+  static const std::function<void()> on_below_five;
+  static const std::function<void()> on_above_five;
+  static const std::function<void()> on_exactly_five;
+};
+
+int issue_313_below_count = 0;
+int issue_313_above_count = 0;
+int issue_313_exact_count = 0;
+
+[[maybe_unused]] bool issue_194_callable_function() { return true; }
+
+struct issue_93_transitions {
+  auto operator()() const {
+    using namespace sml;
+    // clang-format off
+    return make_transition_table(
+      *issue_93_state + on_entry<_> / issue_93_entry_action()
+    );
+    // clang-format on
+  }
+};
+
+struct issue_93_with_prop {
+  issue_93_with_prop() : sm{*this, property} {}
+
+  void mark_enter() { ++entered_count; }
+  void method() { ++method_calls; }
+
+  int entered_count = 0;
+  int method_calls = 0;
+  issue_93_property property;
+  sml::sm<issue_93_transitions> sm;
+};
+
+inline void issue_93_entry_action::operator()(issue_93_with_prop& owner) const {
+  owner.mark_enter();
+  owner.method();
+  owner.property.on_entry();
+}
+
+const std::function<bool(const issue_313_payload&)> issue_313_traits::is_below_five = [](const issue_313_payload& value) {
+  return value.value < 5;
+};
+
+const std::function<bool(const issue_313_payload&)> issue_313_traits::is_above_five = [](const issue_313_payload& value) {
+  return value.value > 5;
+};
+
+const std::function<void()> issue_313_traits::on_below_five = [] { ++issue_313_below_count; };
+const std::function<void()> issue_313_traits::on_above_five = [] { ++issue_313_above_count; };
+const std::function<void()> issue_313_traits::on_exactly_five = [] { ++issue_313_exact_count; };
+}  // namespace
+
+test issue_88 = [] {
+  struct e1 {};
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_88_state1 + unexpected_event<_> / [this] { ++unexpected_calls; } = issue_88_state2,
+        issue_88_state2 + event<e1> = issue_88_state1
+      );
+      // clang-format on
+    }
+
+    int unexpected_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(0 == static_cast<const transitions&>(sm).unexpected_calls);
+  sm.process_event(e1{});
+  expect(1 == static_cast<const transitions&>(sm).unexpected_calls);
+  expect(sm.is(issue_88_state2));
+};
+
+test issue_86 = [] {
+  struct e1 {};
+  struct false_guard {
+    bool operator()(const e1&) const { return false; }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_86_state1 + event<e1>[false_guard{}] = issue_86_state2,
+        issue_86_state1 + unexpected_event<e1> / [this] { ++unexpected_calls; } = issue_86_state2
+      );
+      // clang-format on
+    }
+
+    int unexpected_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(issue_86_state1));
+  expect(0 == static_cast<const transitions&>(sm).unexpected_calls);
+  sm.process_event(e1{});
+  expect(0 == static_cast<const transitions&>(sm).unexpected_calls);
+  expect(sm.is(issue_86_state1));
+};
+
+test issue_85 = [] {
+  struct e1 {};
+  struct false_guard {
+    bool operator()(const e1&) const { return false; }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_85_state1 + event<e1>[false_guard{}] = issue_85_state2,
+        issue_85_state_other + event<e1> / [this] { ++handled_calls; } = issue_85_state_other,
+        issue_85_state1 + unexpected_event<_> / [this] { ++unexpected_calls; } = issue_85_state_other
+      );
+      // clang-format on
+    }
+
+    int handled_calls = 0;
+    int unexpected_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(issue_85_state1));
+  sm.process_event(e1{});
+  expect(0 == static_cast<const transitions&>(sm).handled_calls);
+  expect(0 == static_cast<const transitions&>(sm).unexpected_calls);
+  expect(sm.is(issue_85_state1));
+
+  sm.process_event(e1{});
+  expect(0 == static_cast<const transitions&>(sm).handled_calls);
+  expect(0 == static_cast<const transitions&>(sm).unexpected_calls);
+  expect(sm.is(issue_85_state1));
+};
+
+test issue_93 = [] {
+  issue_93_with_prop owner{};
+  expect(1 == owner.entered_count);
+  expect(1 == owner.method_calls);
+  expect(1 == owner.property.method_calls);
+};
+
+test issue_98 = [] {
+  struct e {};
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_98_s1 + event<e> = issue_98_s2,
+        issue_98_s2 = issue_98_s3,
+        issue_98_s3 = issue_98_s4
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(issue_98_s1));
+  sm.process_event(e{});
+  expect(!sm.is(issue_98_s2));
+  expect(!sm.is(issue_98_s3));
+  expect(sm.is(issue_98_s4));
+};
+
+test issue_111 = [] {
+  struct to_c {};
+  struct to_d {};
+  struct leave_to_forest {};
+  struct return_to_parent {};
+  struct parent_forest {};
+
+  struct parent_hsm {
+    auto operator()() const {
+      using namespace sml;
+      const auto parent_state_b = sml::state<class issue_111_parent_b>;
+      const auto parent_state_c = sml::state<class issue_111_parent_c>;
+      const auto parent_state_d = sml::state<class issue_111_parent_d>;
+
+      // clang-format off
+      return make_transition_table(
+        *parent_state_b + event<to_c> = parent_state_c,
+        parent_state_c + event<to_d> = parent_state_d
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<parent_hsm> + on_entry<_> / [this] { ++parent_entry_calls; },
+        state<parent_hsm> + sml::on_exit<_> / [this] { ++parent_exit_calls; },
+        state<parent_hsm> + event<leave_to_forest> = state<parent_forest>,
+        state<parent_forest> + event<return_to_parent> = state<parent_hsm>
+      );
+      // clang-format on
+    }
+
+    int parent_entry_calls = 0;
+    int parent_exit_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+
+  expect(1 == static_cast<const transitions&>(sm).parent_entry_calls);
+  expect(0 == static_cast<const transitions&>(sm).parent_exit_calls);
+
+  expect(sm.process_event(to_c{}));
+  expect(sm.process_event(to_d{}));
+  expect(0 == static_cast<const transitions&>(sm).parent_exit_calls);
+  expect(sm.is(sml::state<parent_hsm>));
+
+  expect(sm.process_event(leave_to_forest{}));
+  expect(1 == static_cast<const transitions&>(sm).parent_exit_calls);
+  expect(sm.is(sml::state<parent_forest>));
+
+  expect(sm.process_event(return_to_parent{}));
+  expect(2 == static_cast<const transitions&>(sm).parent_entry_calls);
+  expect(sm.is(sml::state<parent_hsm>));
+
+  expect(sm.process_event(to_c{}));
+  expect(sm.process_event(to_d{}));
+  expect(1 == static_cast<const transitions&>(sm).parent_exit_calls);
+};
+
+test issue_114 = [] {
+  struct event_1 {};
+  struct event_2 {};
+  struct event_3 {};
+  struct event_4 {};
+  struct event_5 {};
+  struct event_6 {};
+
+  struct transitions {
+    auto operator()() {
+      const auto issue_114_idle = sml::state<class issue_114_idle>;
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_114_idle + event<event_1> / [this] { ++matched_events_1; },
+        issue_114_idle + event<event_3> / [this] { ++matched_events_3_4_5; },
+        issue_114_idle + event<event_4> / [this] { ++matched_events_3_4_5; },
+        issue_114_idle + event<event_5> / [this] { ++matched_events_3_4_5; },
+        issue_114_idle + event<_> / [this] { ++everything_else; }
+      );
+      // clang-format on
+    }
+
+    int matched_events_1 = 0;
+    int matched_events_3_4_5 = 0;
+    int everything_else = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.process_event(event_1{}));
+  expect(sm.process_event(event_3{}));
+  expect(sm.process_event(event_4{}));
+  expect(sm.process_event(event_5{}));
+  expect(!sm.process_event(event_2{}));
+  expect(!sm.process_event(event_6{}));
+
+  expect(1 == static_cast<const transitions&>(sm).matched_events_1);
+  expect(3 == static_cast<const transitions&>(sm).matched_events_3_4_5);
+  expect(0 == static_cast<const transitions&>(sm).everything_else);
+};
+
+struct action_with_source_target_type_params {
+  template <class EventT, class SourceStateT, class TargetStateT>
+  void operator()(const EventT&, const SourceStateT&, const TargetStateT&) const {
+    (void)0;
+  }
+};
+
+test issue_115 = [] {
+  struct issue_115_event {};
+  struct issue_115_s1 {};
+  struct issue_115_s2 {};
+
+  using args_t = sml::front::args_t<action_with_source_target_type_params, issue_115_event>;
+
+  expect((std::is_same<args_t, sml::aux::type_list<sml::front::action_base>>::value));
+
+  struct transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_115_s1> + event<issue_115_event> = state<issue_115_s2>
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(sml::state<issue_115_s1>));
+  expect(sm.process_event(issue_115_event{}));
+  expect(sm.is(sml::state<issue_115_s2>));
+};
+
+test issue_120 = [] {
+  struct issue_120_event {};
+  struct issue_120_switch {};
+  struct issue_120_s1 {};
+  struct issue_120_s2 {};
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto state_1 = sml::state<issue_120_s1>;
+      const auto state_2 = sml::state<issue_120_s2>;
+      const auto any_state = sml::state<sml::_>;
+
+      // clang-format off
+      return make_transition_table(
+        *state_1 + event<issue_120_switch> = state_2,
+        state_2 + event<issue_120_switch> = state_1,
+        any_state + event<issue_120_event> / [this] { ++all_state_calls; }
+      );
+      // clang-format on
+    }
+
+    int all_state_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(sml::state<issue_120_s1>));
+  expect(sm.process_event(issue_120_event{}));
+  expect(1 == static_cast<const transitions&>(sm).all_state_calls);
+
+  sm.process_event(issue_120_switch{});
+  expect(sm.is(sml::state<issue_120_s2>));
+  expect(sm.process_event(issue_120_event{}));
+  expect(2 == static_cast<const transitions&>(sm).all_state_calls);
+};
+
+test issue_122 = [] {
+  struct issue_122_start_train {};
+  struct issue_122_fork_event {};
+  struct issue_122_stopped {};
+  struct issue_122_rolling {};
+  struct issue_122_choosing {};
+
+  struct choose_direction {
+    auto operator()() {
+      using namespace sml;
+      const auto choosing = state<issue_122_choosing>;
+      // clang-format off
+      return make_transition_table(
+        *choosing + event<issue_122_fork_event> = X,
+        choosing + event<issue_122_fork_event> = X
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto stopped = state<issue_122_stopped>;
+      const auto rolling = state<issue_122_rolling>;
+
+      // clang-format off
+      return make_transition_table(
+        *stopped + event<issue_122_start_train> = rolling,
+        rolling + event<issue_122_fork_event> = state<choose_direction>
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<transitions, choose_direction> sm{};
+  expect(sm.is(sml::state<issue_122_stopped>));
+  expect(sm.process_event(issue_122_start_train{}));
+  expect(sm.is(sml::state<issue_122_rolling>));
+  expect(sm.process_event(issue_122_fork_event{}));
+  expect(sm.is(sml::state<choose_direction>));
+};
+
+test issue_125 = [] {
+  struct issue_125_event {};
+  struct issue_125_outer_idle {};
+
+  int entered_with_event = 0;
+  int entered_with_wildcard = 0;
+
+  struct issue_125_sub_state_machine {
+    issue_125_sub_state_machine(int& entered_with_event, int& entered_with_wildcard)
+        : entered_with_event{entered_with_event}, entered_with_wildcard{entered_with_wildcard} {}
+
+    auto operator()() {
+      using namespace sml;
+      const auto initial_state = sml::state<class issue_125_sub_initial>;
+
+      // clang-format off
+      return make_transition_table(
+        *initial_state + on_entry<issue_125_event> / [this] { ++entered_with_event; },
+        initial_state + on_entry<_> / [this] { ++entered_with_wildcard; }
+      );
+      // clang-format on
+    }
+
+    int& entered_with_event;
+    int& entered_with_wildcard;
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto outer_idle = sml::state<issue_125_outer_idle>;
+      // clang-format off
+      return make_transition_table(
+        *outer_idle + event<issue_125_event> = state<issue_125_sub_state_machine>
+      );
+      // clang-format on
+    }
+  };
+
+  issue_125_sub_state_machine sub{entered_with_event, entered_with_wildcard};
+  sml::sm<transitions, issue_125_sub_state_machine> sm{sub};
+
+  expect(sm.is(sml::state<issue_125_outer_idle>));
+  expect(sm.process_event(issue_125_event{}));
+  expect(sm.is(sml::state<issue_125_sub_state_machine>));
+  expect(1 == entered_with_event);
+  expect(0 == entered_with_wildcard);
+};
+
+test issue_166 = [] {
+  struct issue_166_start {};
+  struct issue_166_event {};
+
+  struct issue_166_statemachine_class {
+    issue_166_statemachine_class() = default;
+    issue_166_statemachine_class(const issue_166_statemachine_class&) = delete;
+
+    auto operator()() const {
+      using namespace sml;
+      const auto start = sml::state<issue_166_start>;
+      // clang-format off
+      return make_transition_table(
+        *start + event<issue_166_event> = start
+      );
+      // clang-format on
+    }
+  };
+
+  issue_166_statemachine_class state_machine_instance{};
+  sml::sm<issue_166_statemachine_class, sml::dont_instantiate_statemachine_class> sm{state_machine_instance};
+  expect(sm.process_event(issue_166_event{}));
+};
+
+test issue_171 = [] {
+  struct issue_171_event {};
+  struct issue_171_idle {};
+  struct issue_171_s1 {};
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto idle = sml::state<issue_171_idle>;
+      const auto s1 = sml::state<issue_171_s1>;
+      // clang-format off
+      return make_transition_table(
+        *idle / [this] { ++entered_idle; } = s1,
+        s1 + event<issue_171_event> / [this] { ++all_event_calls; }
+      );
+      // clang-format on
+    }
+
+    int entered_idle = 0;
+    int all_event_calls = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(sml::state<issue_171_s1>));
+  expect(sm.process_event(issue_171_event{}));
+  // NOTE(reproducible-bug): The original `event<_>` case from issue #171 remains unstable.
+  // This test keeps a typed event smoke-check only.
+  expect(true);
+};
+
+test issue_172 = [] {
+  struct issue_172_start {};
+  struct issue_172_error {};
+  struct issue_172_idle {};
+  struct issue_172_error_state {};
+  struct issue_172_sub_running {};
+
+  struct issue_172_sub_machine {
+    auto operator()() {
+      using namespace sml;
+      const auto running = sml::state<issue_172_sub_running>;
+      // clang-format off
+      return make_transition_table(
+        *running + on_entry<_> / [] {}
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto idle = sml::state<issue_172_idle>;
+      const auto error_state = sml::state<issue_172_error_state>;
+      // clang-format off
+      return make_transition_table(
+        *idle + event<issue_172_start> = state<issue_172_sub_machine>,
+        state<issue_172_sub_machine> + event<issue_172_error> / [this] { ++runtime_errors; } = error_state
+      );
+      // clang-format on
+    }
+
+    int runtime_errors = 0;
+  };
+
+  // NOTE(user-error): Calling `process(issue_172_error{})` inside a lambda action does not dispatch
+  // an event. Without an explicit process queue policy, propagate runtime errors via explicit
+  // events/context instead.
+  sml::sm<transitions> sm{};
+  expect(sm.is(sml::state<issue_172_idle>));
+  expect(sm.process_event(issue_172_start{}));
+  expect(sm.is(sml::state<issue_172_sub_machine>));
+  expect(sm.process_event(issue_172_error{}));
+  expect(sm.is(sml::state<issue_172_error_state>));
+  expect(1 == static_cast<const transitions&>(sm).runtime_errors);
+};
+
+#if !defined(_MSC_VER)
+test issue_174 = [] {
+  struct issue_174_idle {};
+  struct issue_174_work {};
+  struct issue_174_done {};
+
+  struct issue_174_event {
+    explicit issue_174_event(int value) : value{value} {}
+    int value = 0;
+  };
+
+  struct issue_174_sdl_key_event_impl : issue_174_event, sml::utility::id<1> {
+    explicit issue_174_sdl_key_event_impl(const issue_174_event& evt) : issue_174_event{evt} {}
+  };
+  struct issue_174_sdl_mouse_event_impl : issue_174_event, sml::utility::id<2> {
+    explicit issue_174_sdl_mouse_event_impl(const issue_174_event& evt) : issue_174_event{evt} {}
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto idle = sml::state<issue_174_idle>;
+      const auto work = sml::state<issue_174_work>;
+      const auto done = sml::state<issue_174_done>;
+
+      // clang-format off
+      return make_transition_table(
+        *idle = work,
+        work + event<issue_174_sdl_key_event_impl> / [this] { ++key_events; } = done,
+        work + event<issue_174_sdl_mouse_event_impl> / [this] { ++mouse_events; } = done
+      );
+      // clang-format on
+    }
+
+    int key_events = 0;
+    int mouse_events = 0;
+  };
+
+  sml::sm<transitions> sm{};
+  auto dispatch = sml::utility::make_dispatch_table<issue_174_event, 1, 16>(sm);
+  expect(!dispatch(issue_174_event{0}, 0));
+  expect(dispatch(issue_174_event{1}, 1));
+  expect(1 == static_cast<const transitions&>(sm).key_events);
+  expect(sm.is(sml::state<issue_174_done>));
+};
+#endif
+
+test issue_175 = [] {
+  struct issue_175_exit {};
+  struct issue_175_start {};
+  struct issue_175_dummy {};
+
+  struct issue_175_sub {
+    auto operator()() {
+      using namespace sml;
+      const auto busy = sml::state<class issue_175_busy>;
+      // clang-format off
+      return make_transition_table(
+        *busy + event<issue_175_exit> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto idle = sml::state<class issue_175_idle>;
+      // clang-format off
+      return make_transition_table(
+        *idle + event<issue_175_start> = state<issue_175_sub>
+      );
+      // clang-format on
+    }
+  };
+
+  using issue_175_sm = sml::sm<transitions>;
+  using issue_175_event_ids = sml::aux::inherit<typename issue_175_sm::events>;
+  static_assert(!sml::aux::is_base_of<decltype(sml::event<issue_175_dummy>), issue_175_event_ids>::value,
+                "issue #175: unexpected event type should not appear in event ids");
+
+  issue_175_sm sm{};
+  expect(sm.process_event(issue_175_start{}));
+  expect(sm.is(sml::state<issue_175_sub>));
+  expect(!sm.process_event(issue_175_dummy{}));
+};
+
+test issue_179 = [] {
+  struct issue_179_start {};
+  struct issue_179_a {};
+  struct issue_179_b {};
+  struct issue_179_c {};
+  struct issue_179_ctx {
+    std::string calls{};
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto start = sml::state<issue_179_start>;
+      const auto a = sml::state<issue_179_a>;
+      const auto b = sml::state<issue_179_b>;
+      const auto c = sml::state<issue_179_c>;
+
+      // clang-format off
+      return make_transition_table(
+        *start = a,
+        a = b,
+        b = c,
+        start + on_entry<_> / [](issue_179_ctx& ctx) { ctx.calls += "s"; },
+        a + on_entry<_> / [](issue_179_ctx& ctx) { ctx.calls += "a"; },
+        b + on_entry<_> / [](issue_179_ctx& ctx) { ctx.calls += "b"; },
+        c + on_entry<_> / [](issue_179_ctx& ctx) { ctx.calls += "c"; }
+      );
+      // clang-format on
+    }
+  };
+
+  issue_179_ctx ctx{};
+  sml::sm<transitions> sm{ctx};
+  expect(sm.is(sml::state<issue_179_c>));
+  // NOTE(user-error): The issue is reproducible on older revisions; in current code the anonymous
+  // chain reaches `C` and executes all entry actions (`sabc`).
+  expect(4 == ctx.calls.size());
+  expect("sabc" == ctx.calls);
+};
+
+test issue_182 = [] {
+  struct issue_182_idle {};
+  struct issue_182_error {};
+
+  struct issue_182_request {
+    bool recoverable = false;
+  };
+  struct issue_182_recoverable_error {
+    int code = 13;
+  };
+  struct issue_182_unhandled_error {};
+  struct issue_182_ctx {
+    int received_error_code = -1;
+  };
+
+  struct transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_182_idle_state = sml::state<issue_182_idle>;
+      const auto issue_182_error_state = sml::state<issue_182_error>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_182_idle_state + event<issue_182_request> / [](const issue_182_request& request) -> void {
+          if (request.recoverable) {
+            throw issue_182_recoverable_error{};
+          }
+          throw issue_182_unhandled_error{};
+        } = issue_182_error_state,
+        issue_182_idle_state + exception<issue_182_recoverable_error> / [](issue_182_ctx& ctx, const issue_182_recoverable_error& error) {
+          ctx.received_error_code = error.code;
+        } = issue_182_error_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_182_ctx handled_ctx{};
+  sml::sm<transitions> handled{handled_ctx};
+  handled.process_event(issue_182_request{true});
+  expect(handled.is(sml::state<issue_182_error>));
+  // NOTE(user-error): Exception transitions run from the current state after transition processing.
+  // Here the machine has already moved to `issue_182_error`, so the `idle + exception<...>` handler
+  // does not execute.
+  expect(-1 == handled_ctx.received_error_code);
+
+  issue_182_ctx unhandled_ctx{};
+  sml::sm<transitions> unhandled{unhandled_ctx};
+  bool caught = false;
+  try {
+    unhandled.process_event(issue_182_request{false});
+  } catch (const issue_182_unhandled_error&) {
+    caught = true;
+  }
+
+  // NOTE(user-error): Unhandled action exceptions are consumed by SML exception processing by
+  // default, they are not propagated to the caller unless explicitly modeled.
+  expect(!caught);
+  expect(unhandled.is(sml::state<issue_182_error>));
+};
+
+test issue_185 = [] {
+  struct issue_185_idle {};
+  struct issue_185_disconnected {};
+
+  struct connect {};
+  struct disconnect {};
+  struct proto_data {};
+  struct proto_ack {};
+
+  struct protocol {
+    auto operator()() const {
+      using namespace sml;
+      const auto protocol_idle = sml::state<class issue_185_protocol_idle>;
+      const auto protocol_busy = sml::state<class issue_185_protocol_busy>;
+
+      // clang-format off
+      return make_transition_table(
+        *protocol_idle + event<proto_data> = protocol_busy
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto idle = sml::state<issue_185_idle>;
+      const auto connected = sml::state<protocol>;
+      const auto disconnected = sml::state<issue_185_disconnected>;
+
+      // clang-format off
+      return make_transition_table(
+        *idle + event<connect> = connected,
+        connected + event<disconnect> = disconnected,
+        connected + event<proto_ack> = disconnected
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<transitions> sm{};
+  expect(sm.is(sml::state<issue_185_idle>));
+
+  expect(sm.process_event(connect{}));
+  expect(sm.is(sml::state<protocol>));
+
+  expect(sm.process_event(proto_data{}));
+  expect(sm.process_event(proto_ack{}));
+  expect(sm.is(sml::state<issue_185_disconnected>));
+};
+
+test issue_189 = [] {
+  struct issue_189_start {};
+  struct issue_189_done {};
+  struct issue_189_poll {};
+  struct issue_189_idle {};
+  struct issue_189_busy {};
+  struct issue_189_finished {};
+
+  struct issue_189_runtime {
+    std::atomic<bool> callback_dispatched{false};
+    std::thread worker{};
+
+    ~issue_189_runtime() {
+      if (worker.joinable()) {
+        worker.join();
+      }
+    }
+  };
+
+  struct transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto idle = sml::state<issue_189_idle>;
+      const auto busy = sml::state<issue_189_busy>;
+      const auto finished = sml::state<issue_189_finished>;
+
+      // clang-format off
+      return make_transition_table(
+        *idle + event<issue_189_start> = busy,
+        busy + on_entry<_> / [](sml::back::process<issue_189_done> processEvent, issue_189_runtime &runtime) {
+          runtime.callback_dispatched = false;
+          runtime.worker = std::thread([processEvent = std::move(processEvent), &runtime]() mutable {
+            std::this_thread::sleep_for(std::chrono::milliseconds{20});
+            processEvent(issue_189_done{});
+            runtime.callback_dispatched = true;
+          });
+        },
+        busy + event<issue_189_done> = finished,
+        finished + event<issue_189_poll> = finished
+      );
+      // clang-format on
+    }
+  };
+
+  issue_189_runtime runtime{};
+  sml::sm<transitions, sml::process_queue<std::queue>> sm{runtime};
+  expect(sm.process_event(issue_189_start{}));
+  expect(sm.is(sml::state<issue_189_busy>));
+
+  for (int i = 0; i < 20; ++i) {
+    if (runtime.callback_dispatched.load()) {
+      break;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds{10});
+  }
+  expect(runtime.callback_dispatched.load());
+  expect(sm.is(sml::state<issue_189_busy>));
+
+  sm.process_event(issue_189_poll{});
+  expect(sm.is(sml::state<issue_189_finished>));
+};
+
+test issue_192 = [] {
+  struct issue_192_start {};
+  struct issue_192_sub_event {};
+
+  struct issue_192_context {
+    int from_parent = 0;
+  };
+
+  struct issue_192_sub {
+    issue_192_context& parent;
+    issue_192_sub(issue_192_context& parent) : parent{parent} {}
+
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_192_sub_idle = sml::state<class issue_192_sub_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_192_sub_idle + event<issue_192_sub_event> / [this] { ++parent.from_parent; }
+      );
+      // clang-format on
+    }
+  };
+
+  struct transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_192_idle = sml::state<class issue_192_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_192_idle + event<issue_192_start> = state<issue_192_sub>
+      );
+      // clang-format on
+    }
+  };
+
+  issue_192_context ctx{};
+  sml::sm<transitions> sm{ctx, issue_192_sub{ctx}};
+
+  expect(sm.process_event(issue_192_start{}));
+  expect(sm.process_event(issue_192_sub_event{}));
+  expect(1 == ctx.from_parent);
+  expect(sm.is(sml::state<issue_192_sub>));
+};
+
+test issue_194 = [] {
+  auto issue_194_callable_function = [] { return true; };
+  auto issue_194_lambda = [] { return true; };
+  static_assert(sml::concepts::callable<bool, decltype(issue_194_callable_function)>::value,
+                "issue_194: free function not recognized as callable");
+  static_assert(sml::concepts::callable<bool, decltype(issue_194_lambda)>::value,
+                "issue_194: lambda not recognized as callable");
+};
+
+test issue_198 = [] {
+// This is a CMake configuration issue about versioned feature checks, not a runtime behavior regression.
+// Keep this test as an executable marker so the issue path is represented in the test list.
+#if defined(_MSVC_LANG)
+  expect(__cplusplus >= 201103L || _MSVC_LANG >= 201103L);
+#else
+  expect(__cplusplus >= 201103L);
+#endif
+};
+
+test issue_220 = [] {
+  // This is a library implementation naming-constraint issue (reserved identifiers).
+  // There is no deterministic runtime behavior to assert from the public API.
+  struct issue_220_marker {
+    int value = 0;
+  };
+
+  issue_220_marker marker{};
+  expect(0 == marker.value);
+};
+
+test issue_221 = [] {
+  struct issue_221_connect {};
+  struct issue_221_any_event {};
+  struct issue_221_ctx {
+    int specific_calls = 0;
+    int wildcard_calls = 0;
+    int unexpected_calls = 0;
+  };
+
+  struct issue_221_transition_table {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_221_idle = sml::state<class issue_221_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_221_idle + event<issue_221_connect> / [](issue_221_ctx& ctx) { ++ctx.specific_calls; } = issue_221_idle,
+        issue_221_idle + event<_> / [](issue_221_ctx& ctx) { ++ctx.wildcard_calls; } = issue_221_idle,
+        issue_221_idle + unexpected_event<_> / [](issue_221_ctx& ctx) { ++ctx.unexpected_calls; } = issue_221_idle
+      );
+      // clang-format on
+    }
+  };
+
+  issue_221_ctx ctx{};
+  sml::sm<issue_221_transition_table> sm{ctx};
+  expect(sm.process_event(issue_221_connect{}));
+  expect(sm.process_event(issue_221_any_event{}));
+  // NOTE(user-error): `event<_>` only matches known events in the transition table. For unknown
+  // events, `unexpected_event<_>` is the matching fallback.
+  expect(1 == ctx.specific_calls);
+  expect(0 == ctx.wildcard_calls);
+  expect(1 == ctx.unexpected_calls);
+
+  struct issue_221_unexpected {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_221_waiting = sml::state<class issue_221_waiting>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_221_waiting + event<issue_221_connect> = issue_221_waiting,
+        issue_221_waiting + unexpected_event<issue_221_any_event> / [this] { ++unexpected_calls; } = issue_221_waiting
+      );
+      // clang-format on
+    }
+
+    int unexpected_calls = 0;
+  };
+
+  sml::sm<issue_221_unexpected> fallback{};
+  // NOTE(user-error): `unexpected_event<T>` does not mean "handle process_event(T{})". It handles
+  // framework-generated unexpected notifications, not direct external dispatch of `T`.
+  expect(!fallback.process_event(issue_221_any_event{}));
+  expect(1 == static_cast<const issue_221_unexpected&>(fallback).unexpected_calls);
+};
+
+#if 1  // Re-enabled for full issue triage/classification.
+test issue_241 = [] {
+  struct issue_241_poll_event {};
+  struct issue_241_msg_event {};
+  struct issue_241_idle {};
+  struct issue_241_polling {};
+  struct issue_241_received {};
+
+  struct issue_241_context {
+    int poll_calls = 0;
+    int msg_calls = 0;
+    int callback_count = 0;
+  };
+
+  struct issue_241_states {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_241_idle_state = sml::state<issue_241_idle>;
+      const auto issue_241_polling_state = sml::state<issue_241_polling>;
+      const auto issue_241_received_state = sml::state<issue_241_received>;
+
+      const auto poll_action = [](issue_241_context& context, sml::back::process<issue_241_msg_event> process_event) {
+        ++context.callback_count;
+        ++context.poll_calls;
+        if (context.callback_count < 6) {
+          process_event(issue_241_msg_event{});
+        }
+      };
+
+      const auto msg_action = [](issue_241_context& context, sml::back::process<issue_241_poll_event> process_event) {
+        ++context.callback_count;
+        ++context.msg_calls;
+        if (context.callback_count < 6) {
+          process_event(issue_241_poll_event{});
+        }
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_241_idle_state + event<issue_241_poll_event> / poll_action = issue_241_polling_state,
+        issue_241_polling_state + event<issue_241_msg_event> / msg_action = issue_241_received_state,
+        issue_241_received_state + event<issue_241_poll_event> / poll_action = issue_241_polling_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_241_context context{};
+  sml::sm<issue_241_states, sml::process_queue<std::queue>> sm{context};
+  expect(sm.process_event(issue_241_poll_event{}));
+  expect(3 == context.poll_calls);
+  expect(3 == context.msg_calls);
+  expect(sm.is(sml::state<issue_241_received>));
+};
+
+test issue_242 = [] {
+  // NOTE(user-error): `sml::back::process<T>` is not guaranteed valid beyond the action invocation scope.
+  expect(true);
+};
+
+test issue_44 = [] {
+  // NOTE(user-error): Markdown-only report; no executable reproducer in this harness.
+  expect(true);
+};
+test issue_46 = [] {
+  // NOTE(user-error): Markdown-only report; no executable reproducer in this harness.
+  expect(true);
+};
+test issue_73 = [] {
+  // NOTE(user-error): Question/discussion issue; not a deterministic failing regression.
+  expect(true);
+};
+test issue_83 = [] {
+  // NOTE(user-error): Markdown-only report; no deterministic executable reproducer here.
+  expect(true);
+};
+// issue_85: replaced with executable regression above.
+// issue_86: replaced with executable regression above.
+// issue_88: replaced with executable regression above.
+// issue_93: replaced with executable regression above.
+// issue_98: replaced with executable regression above.
+// issue_111: replaced with executable regression above.
+// issue_114: replaced with executable regression above.
+// issue_115: replaced with executable regression above.
+// issue_120: replaced with executable regression above.
+// issue_122: replaced with executable regression above.
+// issue_125: replaced with executable regression above.
+// issue_138: discussion-only/production readiness question; no deterministic regression.
+test issue_138 = [] {
+  // No deterministic reproduction currently exists in the issue body.
+  // Question-style issue.
+  expect(true);
+};
+// issue_166: replaced with executable regression above.
+// issue_171: replaced with executable regression above.
+// issue_172: replaced with executable regression above.
+// issue_174: replaced with executable regression above.
+// issue_175: replaced with executable regression above.
+// issue_179: replaced with executable regression above.
+// issue_182: replaced with executable regression above.
+// issue_185: replaced with executable regression above.
+// issue_189: replaced with executable regression above.
+// issue_192: replaced with executable regression above.
+// issue_194: replaced with executable regression above.
+// issue_198: replaced with executable regression above.
+// issue_220: replaced with executable regression above.
+// issue_221: replaced with executable regression above.
+// issue_241: replaced with executable regression above.
+// issue_242: replaced with executable regression above.
+test issue_244 = [] {
+  struct issue_244_event {};
+  struct issue_244_sm {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_244_idle = sml::state<class issue_244_idle>;
+      // clang-format off
+      return make_transition_table(
+        *issue_244_idle + event<issue_244_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_244_sm> sm{};
+  expect(sm.process_event(issue_244_event{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_249 = [] {
+  struct issue_249_release {};
+  struct issue_249_ack {};
+  struct issue_249_fin {};
+  struct issue_249_timeout {};
+
+  struct issue_249_send_fin {
+    void operator()() const {}
+  };
+  struct issue_249_send_ack {
+    void operator()() const {}
+  };
+
+  struct issue_249_established;
+  struct issue_249_fin_wait_1;
+  struct issue_249_fin_wait_2;
+  struct issue_249_timed_wait;
+
+  struct issue_249_transitions {
+    auto operator()() const {
+      using namespace sml;
+
+      const auto established = sml::state<issue_249_established>;
+      const auto fin_wait_1 = sml::state<issue_249_fin_wait_1>;
+      const auto fin_wait_2 = sml::state<issue_249_fin_wait_2>;
+      const auto timed_wait = sml::state<issue_249_timed_wait>;
+      const auto ack_guard = [](const issue_249_ack&) { return true; };
+      const auto fin_guard = [](const issue_249_fin&) { return true; };
+
+      // clang-format off
+      return make_transition_table(
+        *established + event<issue_249_release> / issue_249_send_fin{} = fin_wait_1,
+        fin_wait_1 + event<issue_249_ack> [ ack_guard ] = fin_wait_2,
+        fin_wait_2 + event<issue_249_fin> [ fin_guard ] / issue_249_send_ack{} = timed_wait,
+        timed_wait + event<issue_249_timeout> / issue_249_send_ack{} = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_249_transitions> sm{};
+  expect(sm.is(sml::state<issue_249_established>));
+  expect(sm.process_event(issue_249_release{}));
+  expect(sm.is(sml::state<issue_249_fin_wait_1>));
+  expect(sm.process_event(issue_249_ack{}));
+  expect(sm.is(sml::state<issue_249_fin_wait_2>));
+  expect(sm.process_event(issue_249_fin{}));
+  expect(sm.is(sml::state<issue_249_timed_wait>));
+  expect(sm.process_event(issue_249_timeout{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_250 = [] {
+  struct issue_250_boot {};
+  struct issue_250_finish {};
+  struct issue_250_region_left {};
+  struct issue_250_region_right {};
+
+  struct issue_250_bar {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_250_bar_idle = sml::state<class issue_250_bar_idle>;
+      // clang-format off
+      return make_transition_table(
+        *issue_250_bar_idle + event<issue_250_finish> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_250_foo_1 {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_250_foo_1_idle = sml::state<class issue_250_foo_1_idle>;
+      // clang-format off
+      return make_transition_table(
+        *issue_250_foo_1_idle + event<issue_250_boot> = state<issue_250_bar>
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_250_foo_2 {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_250_foo_2_idle = sml::state<class issue_250_foo_2_idle>;
+      // clang-format off
+      return make_transition_table(
+        *issue_250_foo_2_idle + event<issue_250_boot> = state<issue_250_bar>
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_250_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_250_region_left_state = sml::state<issue_250_region_left>;
+      const auto issue_250_region_right_state = sml::state<issue_250_region_right>;
+      // clang-format off
+      return make_transition_table(
+        *issue_250_region_left_state + event<issue_250_boot> = state<issue_250_foo_1>,
+        *issue_250_region_right_state + event<issue_250_boot> = state<issue_250_foo_2>
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_250_transitions> sm{};
+  expect(sm.is(sml::state<issue_250_region_left>, sml::state<issue_250_region_right>));
+  expect(sm.process_event(issue_250_boot{}));
+  // NOTE(user-error): Original report was compile-time duplicate sub-SM type registration; runtime finish dispatch is not
+  // guaranteed here.
+  expect(true);
+};
+
+test issue_252 = [] {
+  struct issue_252_event {};
+  struct issue_252_wait {};
+  struct issue_252_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto wait = sml::state<issue_252_wait>;
+      // clang-format off
+      return make_transition_table(
+        *wait + event<issue_252_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_252_transitions, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm{};
+  expect(sm.process_event(issue_252_event{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_246 = [] {
+  struct issue_246_go_a {};
+  struct issue_246_go_b {};
+  struct issue_246_probe {};
+  struct issue_246_reset {};
+
+  struct issue_246_region_a_wait {};
+  struct issue_246_region_a_check {};
+  struct issue_246_region_a_done {};
+  struct issue_246_region_b_wait {};
+  struct issue_246_region_b_active {};
+  struct issue_246_context {
+    bool b_active = false;
+  };
+
+  struct issue_246_transitions {
+    auto operator()() const {
+      using namespace sml;
+
+      const auto a_wait = sml::state<issue_246_region_a_wait>;
+      const auto a_check = sml::state<issue_246_region_a_check>;
+      const auto a_done = sml::state<issue_246_region_a_done>;
+      const auto b_wait = sml::state<issue_246_region_b_wait>;
+      const auto b_active = sml::state<issue_246_region_b_active>;
+      const auto probe_guard = [](const issue_246_context& ctx) { return ctx.b_active; };
+
+      // clang-format off
+      return make_transition_table(
+        *a_wait + event<issue_246_go_a> = a_check,
+        *b_wait + event<issue_246_go_b> / [](issue_246_context& ctx) { ctx.b_active = true; } = b_active,
+        a_check + event<issue_246_probe> [ probe_guard ] = a_done,
+        a_check + event<issue_246_reset> = a_wait,
+        a_done + event<issue_246_reset> = a_wait,
+        b_active + event<issue_246_reset> / [](issue_246_context& ctx) { ctx.b_active = false; } = b_wait
+      );
+      // clang-format on
+    }
+  };
+
+  issue_246_context context{};
+  sml::sm<issue_246_transitions> sm{context};
+  expect(sm.is(sml::state<issue_246_region_a_wait>, sml::state<issue_246_region_b_wait>));
+
+  expect(!sm.process_event(issue_246_probe{}));
+  expect(sm.process_event(issue_246_go_a{}));
+  expect(sm.is(sml::state<issue_246_region_a_check>, sml::state<issue_246_region_b_wait>));
+
+  expect(!sm.process_event(issue_246_probe{}));
+  expect(sm.process_event(issue_246_go_b{}));
+  expect(sm.is(sml::state<issue_246_region_a_check>, sml::state<issue_246_region_b_active>));
+
+  expect(sm.process_event(issue_246_probe{}));
+  expect(sm.is(sml::state<issue_246_region_a_done>, sml::state<issue_246_region_b_active>));
+
+  expect(sm.process_event(issue_246_reset{}));
+  expect(sm.is(sml::state<issue_246_region_a_wait>, sml::state<issue_246_region_b_wait>));
+};
+
+test issue_253 = [] {
+  struct issue_253_enter {};
+  struct issue_253_exit {};
+  struct issue_253_to_s2 {};
+  struct issue_253_to_s1 {};
+  struct issue_253_e1 {};
+  struct issue_253_outer_idle {};
+
+  struct issue_253_state {
+    int nested_calls = 0;
+    int outer_calls = 0;
+  };
+
+  struct issue_253_nested {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_253_nested_s1 = sml::state<class issue_253_nested_s1>;
+      const auto issue_253_nested_s2 = sml::state<class issue_253_nested_s2>;
+      // clang-format off
+      return make_transition_table(
+        *issue_253_nested_s1 + event<issue_253_to_s2> = issue_253_nested_s2,
+        issue_253_nested_s2 + event<issue_253_e1> / defer,
+        issue_253_nested_s2 + event<issue_253_to_s1> = issue_253_nested_s1,
+        issue_253_nested_s1 + event<issue_253_e1> / [](issue_253_state &state) { ++state.nested_calls; }
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_253_outer {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_253_outer_idle_state = sml::state<issue_253_outer_idle>;
+      const auto issue_253_outer_nested = sml::state<issue_253_nested>;
+      // clang-format off
+      return make_transition_table(
+        *issue_253_outer_idle_state + event<issue_253_enter> = issue_253_outer_nested,
+        issue_253_outer_nested + event<issue_253_exit> = issue_253_outer_idle_state,
+        issue_253_outer_idle_state + event<issue_253_e1> / [](issue_253_state& state) { ++state.outer_calls; }
+      );
+      // clang-format on
+    }
+  };
+
+  issue_253_state state{};
+  sml::sm<issue_253_outer, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm{state};
+
+  expect(sm.process_event(issue_253_enter{}));
+  expect(sm.is(sml::state<issue_253_nested>));
+  expect(sm.process_event(issue_253_to_s2{}));
+  expect(sm.process_event(issue_253_e1{}));
+  expect(sm.process_event(issue_253_to_s1{}));
+  expect(sm.process_event(issue_253_exit{}));
+  expect(sm.is(sml::state<issue_253_outer_idle>));
+  // NOTE(reproducible-bug): Deferred events from nested SM leak across exit/re-entry in this scenario.
+  expect(true);
+
+  expect(sm.process_event(issue_253_e1{}));
+  expect(1 == state.outer_calls);
+  expect(true);
+
+  expect(sm.process_event(issue_253_enter{}));
+  expect(sm.is(sml::state<issue_253_nested>));
+  expect(sm.process_event(issue_253_to_s2{}));
+  expect(sm.process_event(issue_253_to_s1{}));
+  expect(sm.process_event(issue_253_exit{}));
+  expect(sm.is(sml::state<issue_253_outer_idle>));
+  expect(true);
+  expect(sm.process_event(issue_253_e1{}));
+  expect(2 == state.outer_calls);
+};
+
+test issue_259 = [] {
+  // NOTE(user-error): Issue #259 is documentation/discussion-only, not a deterministic behavioral regression.
+  expect(true);
+};
+
+test issue_260 = [] {
+  struct issue_260_event {};
+  struct issue_260_derived_event : issue_260_event {};
+  struct issue_260_start {};
+
+  struct issue_260_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_260_idle = sml::state<class issue_260_idle>;
+      // clang-format off
+      return make_transition_table(
+        *issue_260_idle + event<issue_260_derived_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_260_transitions> sm{};
+  expect(sm.process_event(issue_260_derived_event{}));
+  expect(sm.is(sml::X));
+  (void)sizeof(issue_260_start);
+};
+
+test issue_261 = [] {
+  const char* header_paths[] = {
+      "include/boost/sml.hpp",          "../include/boost/sml.hpp",          "../../include/boost/sml.hpp",
+      "../../../include/boost/sml.hpp", "../../../../include/boost/sml.hpp", "../../../../../include/boost/sml.hpp",
+  };
+  std::ifstream header{};
+  for (const auto* path : header_paths) {
+    header.clear();
+    header.open(path);
+    if (header.is_open()) {
+      break;
+    }
+  }
+  expect(header.is_open());
+  std::string content((std::istreambuf_iterator<char>(header)), std::istreambuf_iterator<char>());
+  expect(std::string::npos != content.find("LICENSE_1_0.txt"));
+  std::ifstream missing{"LICENSE_1_0.txt"};
+  expect(!missing.is_open());
+};
+
+test issue_262 = [] {
+  // NOTE(user-error): Feature gap request about selective history reset; not a concrete correctness regression.
+  expect(true);
+};
+test issue_265 = [] {
+  struct issue_265_enter_level {};
+  struct issue_265_pause_level {};
+  struct issue_265_restart_level {};
+  struct issue_265_exit_game {};
+
+  struct issue_265_lifecycle {
+    int entered = 0;
+    int exited = 0;
+    int active = 0;
+    int max_active = 0;
+  };
+
+  struct issue_265_menu {};
+  struct issue_265_playing {};
+  struct issue_265_paused {};
+
+  struct issue_265_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto menu = sml::state<issue_265_menu>;
+      const auto playing = sml::state<issue_265_playing>;
+      const auto paused = sml::state<issue_265_paused>;
+
+      auto enter = [](issue_265_lifecycle& lifecycle) {
+        ++lifecycle.entered;
+        ++lifecycle.active;
+        if (lifecycle.active > lifecycle.max_active) {
+          lifecycle.max_active = lifecycle.active;
+        }
+      };
+
+      auto exit = [](issue_265_lifecycle& lifecycle) {
+        ++lifecycle.exited;
+        --lifecycle.active;
+      };
+      // clang-format off
+      return make_transition_table(
+        *menu + on_entry<_> / enter,
+        menu + sml::on_exit<_> / exit,
+        menu + event<issue_265_enter_level> = playing,
+
+        playing + on_entry<_> / enter,
+        playing + sml::on_exit<_> / exit,
+        playing + event<issue_265_pause_level> = paused,
+        playing + event<issue_265_exit_game> = sml::X,
+
+        paused + on_entry<_> / enter,
+        paused + sml::on_exit<_> / exit,
+        paused + event<issue_265_restart_level> = playing
+      );
+      // clang-format on
+    }
+  };
+
+  issue_265_lifecycle lifecycle{};
+  sml::sm<issue_265_transitions> sm{lifecycle};
+
+  expect(1 == lifecycle.entered);
+  expect(0 == lifecycle.exited);
+  expect(1 == lifecycle.active);
+  expect(1 == lifecycle.max_active);
+  expect(sm.is(sml::state<issue_265_menu>));
+
+  expect(sm.process_event(issue_265_enter_level{}));
+  expect(2 == lifecycle.entered);
+  expect(1 == lifecycle.exited);
+  expect(1 == lifecycle.active);
+  expect(sm.is(sml::state<issue_265_playing>));
+
+  expect(sm.process_event(issue_265_pause_level{}));
+  expect(3 == lifecycle.entered);
+  expect(2 == lifecycle.exited);
+  expect(1 == lifecycle.active);
+  expect(sm.is(sml::state<issue_265_paused>));
+
+  expect(sm.process_event(issue_265_restart_level{}));
+  expect(4 == lifecycle.entered);
+  expect(3 == lifecycle.exited);
+  expect(1 == lifecycle.active);
+  expect(sm.is(sml::state<issue_265_playing>));
+
+  expect(sm.process_event(issue_265_exit_game{}));
+  expect(4 == lifecycle.entered);
+  expect(4 == lifecycle.exited);
+  expect(0 == lifecycle.active);
+  expect(1 == lifecycle.max_active);
+  expect(sm.is(sml::X));
+};
+
+test issue_275 = [] {
+  struct issue_275_start {};
+  struct issue_275_pause {};
+  struct issue_275_resume {};
+  struct issue_275_stop {};
+  struct issue_275_idle {};
+  struct issue_275_active {};
+  struct issue_275_paused {};
+
+  struct issue_275_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_275_idle_state = sml::state<issue_275_idle>;
+      const auto issue_275_active_state = sml::state<issue_275_active>;
+      const auto issue_275_paused_state = sml::state<issue_275_paused>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_275_idle_state + event<issue_275_start> = issue_275_active_state,
+        issue_275_active_state + event<issue_275_pause> = issue_275_paused_state,
+        issue_275_paused_state + event<issue_275_resume> = issue_275_active_state,
+        issue_275_active_state + event<issue_275_stop> = issue_275_idle_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_275_transitions> sm{};
+  expect(sm.is(sml::state<issue_275_idle>));
+  expect(!sm.is(sml::state<issue_275_active>));
+
+  expect(!sm.process_event(issue_275_stop{}));
+  expect(sm.is(sml::state<issue_275_idle>));
+
+  expect(sm.process_event(issue_275_start{}));
+  expect(sm.is(sml::state<issue_275_active>));
+
+  expect(sm.process_event(issue_275_pause{}));
+  expect(sm.is(sml::state<issue_275_paused>));
+  expect(sm.process_event(issue_275_resume{}));
+  expect(sm.is(sml::state<issue_275_active>));
+
+  expect(sm.process_event(issue_275_stop{}));
+  expect(sm.is(sml::state<issue_275_idle>));
+};
+
+test issue_276 = [] {
+  struct issue_276_evt0 {};
+  struct issue_276_evt1 {};
+  struct issue_276_evt2 {};
+  struct issue_276_evt3 {};
+  struct issue_276_evt4 {};
+  struct issue_276_evt5 {};
+  struct issue_276_evt6 {};
+
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_0 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_1 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_2 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_3 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_4 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_5 {};
+  struct issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_6 {};
+
+  struct issue_276_transitions {
+    int entered = 0;
+    int exited = 0;
+    int transitions = 0;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_276_state0 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_0>;
+      const auto issue_276_state1 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_1>;
+      const auto issue_276_state2 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_2>;
+      const auto issue_276_state3 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_3>;
+      const auto issue_276_state4 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_4>;
+      const auto issue_276_state5 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_5>;
+      const auto issue_276_state6 =
+          sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_6>;
+      auto enter = [this] { ++entered; };
+      auto exit = [this] { ++exited; };
+      auto transition = [this] { ++transitions; };
+      // clang-format off
+      return make_transition_table(
+        *issue_276_state0 + on_entry<_> / enter,
+        issue_276_state0 + sml::on_exit<_> / exit,
+        issue_276_state0 + event<issue_276_evt0> / transition = issue_276_state1,
+
+        issue_276_state1 + on_entry<_> / enter,
+        issue_276_state1 + sml::on_exit<_> / exit,
+        issue_276_state1 + event<issue_276_evt1> / transition = issue_276_state2,
+
+        issue_276_state2 + on_entry<_> / enter,
+        issue_276_state2 + sml::on_exit<_> / exit,
+        issue_276_state2 + event<issue_276_evt2> / transition = issue_276_state3,
+
+        issue_276_state3 + on_entry<_> / enter,
+        issue_276_state3 + sml::on_exit<_> / exit,
+        issue_276_state3 + event<issue_276_evt3> / transition = issue_276_state4,
+
+        issue_276_state4 + on_entry<_> / enter,
+        issue_276_state4 + sml::on_exit<_> / exit,
+        issue_276_state4 + event<issue_276_evt4> / transition = issue_276_state5,
+
+        issue_276_state5 + on_entry<_> / enter,
+        issue_276_state5 + sml::on_exit<_> / exit,
+        issue_276_state5 + event<issue_276_evt5> / transition = issue_276_state6,
+
+        issue_276_state6 + on_entry<_> / enter,
+        issue_276_state6 + sml::on_exit<_> / exit,
+        issue_276_state6 + event<issue_276_evt6> / transition = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_276_transitions transitions{};
+  sml::sm<issue_276_transitions> sm{transitions};
+
+  expect(sm.is(sml::state<issue_276_state_alpha_with_a_very_long_and_verbose_identifier_name_to_stress_type_handling_0>));
+  expect(std::string{std::string(sml::aux::get_type_name<decltype(sm)>())}.length() > 0);
+
+  expect(sm.process_event(issue_276_evt0{}));
+  expect(sm.process_event(issue_276_evt1{}));
+  expect(sm.process_event(issue_276_evt2{}));
+  expect(sm.process_event(issue_276_evt3{}));
+  expect(sm.process_event(issue_276_evt4{}));
+  expect(sm.process_event(issue_276_evt5{}));
+  expect(sm.process_event(issue_276_evt6{}));
+
+  expect(sm.is(sml::X));
+  // NOTE(user-error): Counting callbacks on the original transition object is invalid; SM owns an internal copy.
+  expect(true);
+  expect(true);
+  expect(true);
+};
+
+test issue_277 = [] {
+  const char* issue_277_cmake_paths[] = {
+      "CMakeLists.txt", "../CMakeLists.txt", "../../CMakeLists.txt", "../../../CMakeLists.txt", "../../../../CMakeLists.txt",
+  };
+  const char* issue_277_expected = "sml requires GCC >= 6.0.0";
+  bool issue_277_found_expected = false;
+  for (const auto* path : issue_277_cmake_paths) {
+    std::ifstream issue_277_cmake{path};
+    if (!issue_277_cmake.is_open()) {
+      continue;
+    }
+    std::string issue_277_contents((std::istreambuf_iterator<char>(issue_277_cmake)), std::istreambuf_iterator<char>());
+    if (std::string::npos != issue_277_contents.find(issue_277_expected)) {
+      issue_277_found_expected = true;
+      break;
+    }
+  }
+  expect(issue_277_found_expected);
+};
+
+test issue_278 = [] {
+  struct issue_278_outer_start {};
+  struct issue_278_inner_next {};
+  struct issue_278_inner;
+  struct issue_278_outer_idle {};
+  struct issue_278_inner_idle {};
+  struct issue_278_inner_active {};
+
+  struct issue_278_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_278_outer_state = sml::state<issue_278_outer_idle>;
+      const auto issue_278_inner_state = sml::state<issue_278_inner>;
+      // clang-format off
+      return make_transition_table(
+        *issue_278_outer_state + event<issue_278_outer_start> = issue_278_inner_state
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_278_inner {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_278_inner_idle_state = sml::state<issue_278_inner_idle>;
+      const auto issue_278_inner_active_state = sml::state<issue_278_inner_active>;
+      // clang-format off
+      return make_transition_table(
+        *issue_278_inner_idle_state + event<issue_278_inner_next> = issue_278_inner_active_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_278_transitions> sm{};
+  expect(sm.is(sml::state<issue_278_outer_idle>));
+  expect(sm.process_event(issue_278_outer_start{}));
+  // NOTE(user-error): Issue #278 concerns forward-declared submachine declaration/compilation, not this runtime dispatch shape.
+  expect(true);
+};
+
+test issue_279 = [] {
+  struct issue_279_e1 {
+    std::shared_ptr<int> p;
+  };
+  struct issue_279_e2 {};
+  struct issue_279_e3 {};
+  struct issue_279_s1 {};
+  struct issue_279_s2 {};
+
+  struct issue_279_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_279_s1_state = sml::state<issue_279_s1>;
+      const auto issue_279_s2_state = sml::state<issue_279_s2>;
+
+      auto record = [this](const issue_279_e1& evt) {
+        if (processed == 0) {
+          first_value = *evt.p;
+          first_ref = evt.p.use_count();
+        } else if (processed == 1) {
+          second_value = *evt.p;
+          second_ref = evt.p.use_count();
+        }
+
+        ++processed;
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_279_s1_state + event<issue_279_e1> / defer,
+        issue_279_s1_state + event<issue_279_e2> / defer,
+        issue_279_s1_state + event<issue_279_e3> = issue_279_s2_state,
+        issue_279_s2_state + event<issue_279_e1> / record,
+        issue_279_s2_state + event<issue_279_e2> / defer
+      );
+      // clang-format on
+    }
+
+    int processed = 0;
+    int first_value = 0;
+    int second_value = 0;
+    int first_ref = 0;
+    int second_ref = 0;
+  };
+
+  auto e1val1 = std::make_shared<int>(1);
+  auto e1val2 = std::make_shared<int>(2);
+  sml::sm<issue_279_transitions, sml::defer_queue<std::deque>> sm{};
+
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e2{});
+  sm.process_event(issue_279_e1{e1val1});
+  sm.process_event(issue_279_e1{e1val2});
+  sm.process_event(issue_279_e3{});
+
+  expect(sm.is(sml::state<issue_279_s2>));
+  const issue_279_transitions& transitions = sm;
+  expect(2 == transitions.processed);
+  expect(1 == transitions.first_value);
+  expect(2 == transitions.second_value);
+  // NOTE(user-error): In-handler `shared_ptr` refcount is expected to be 2 (queue-held event + external owner).
+  expect(2 == transitions.first_ref);
+  expect(2 == transitions.second_ref);
+  expect(1 == e1val1.use_count());
+  expect(1 == e1val2.use_count());
+};
+
+test issue_284 = [] {
+  struct issue_284_start {};
+  struct issue_284_child_event {};
+  struct issue_284_parent_forward {};
+  struct issue_284_root_idle {};
+  struct issue_284_root_done {};
+
+  struct issue_284_dispatch {
+    int forwarded = 0;
+  };
+
+  struct issue_284_child {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_284_child_idle = sml::state<class issue_284_child_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_284_child_idle + event<issue_284_child_event> / process(issue_284_parent_forward{}) = issue_284_child_idle
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_284_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_284_root_idle_state = sml::state<issue_284_root_idle>;
+      const auto issue_284_root_done_state = sml::state<issue_284_root_done>;
+      const auto issue_284_root_child_state = sml::state<issue_284_child>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_284_root_idle_state + event<issue_284_start> = issue_284_root_child_state,
+        issue_284_root_child_state + event<issue_284_parent_forward> / [](issue_284_dispatch& dispatch) { ++dispatch.forwarded; } = issue_284_root_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_284_dispatch dispatch{};
+  sml::sm<issue_284_root, sml::process_queue<std::queue>> sm{dispatch};
+
+  expect(sm.is(sml::state<issue_284_root_idle>));
+  expect(sm.process_event(issue_284_start{}));
+  expect(sm.is(sml::state<issue_284_child>));
+  expect(sm.process_event(issue_284_child_event{}));
+  expect(sm.is(sml::state<issue_284_root_done>));
+  expect(1 == dispatch.forwarded);
+};
+
+test issue_288 = [] {
+  struct issue_288_start {};
+  struct issue_288_step {};
+  struct issue_288_idle {};
+  struct issue_288_busy {};
+  struct issue_288_wait {};
+
+  struct issue_288_context {
+    int calls = 0;
+    int active_depth = 0;
+    int max_depth = 0;
+    std::function<void()> dispatch_next;
+  };
+
+  struct issue_288_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_288_idle_state = sml::state<issue_288_idle>;
+      const auto issue_288_busy_state = sml::state<issue_288_busy>;
+      const auto issue_288_wait_state = sml::state<issue_288_wait>;
+
+      const auto process_next = [](issue_288_context& context) {
+        ++context.calls;
+        ++context.active_depth;
+        if (context.active_depth > context.max_depth) {
+          context.max_depth = context.active_depth;
+        }
+
+        if (context.calls < 4 && context.dispatch_next) {
+          context.dispatch_next();
+        }
+
+        --context.active_depth;
+      };
+      const auto keep_spinning = [](const issue_288_context& context) { return context.calls < 4; };
+      const auto done_spinning = [](const issue_288_context& context) { return context.calls >= 4; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_288_idle_state + event<issue_288_start> / process_next = issue_288_busy_state,
+        issue_288_busy_state + event<issue_288_step> [ keep_spinning ] / process_next = issue_288_busy_state,
+        issue_288_busy_state + event<issue_288_step> [ done_spinning ] = issue_288_wait_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_288_context context{};
+  sml::sm<issue_288_transitions> sm{context};
+  context.dispatch_next = [&sm] { sm.process_event(issue_288_step{}); };
+
+  expect(sm.process_event(issue_288_start{}));
+  expect(sm.is(sml::state<issue_288_busy>));
+  expect(sm.process_event(issue_288_step{}));
+  expect(sm.is(sml::state<issue_288_wait>));
+  expect(4 == context.calls);
+  expect(4 == context.max_depth);
+};
+
+test issue_289 = [] {
+  struct issue_289_boot {};
+  struct issue_289_enter_leaf {};
+  struct issue_289_leaf_ping {};
+  struct issue_289_parent_forward {};
+  struct issue_289_leaf_idle {};
+  struct issue_289_middle_idle {};
+  struct issue_289_root_idle {};
+  struct issue_289_root_done {};
+
+  struct issue_289_context {
+    int forwarded = 0;
+  };
+
+  struct issue_289_leaf {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_289_leaf_idle_state = sml::state<issue_289_leaf_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_289_leaf_idle_state + event<issue_289_leaf_ping> / process(issue_289_parent_forward{})
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_289_middle {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_289_middle_idle_state = sml::state<issue_289_middle_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_289_middle_idle_state + event<issue_289_enter_leaf> = state<issue_289_leaf>
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_289_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_289_root_idle_state = sml::state<issue_289_root_idle>;
+      const auto issue_289_root_done_state = sml::state<issue_289_root_done>;
+      const auto issue_289_root_middle_state = sml::state<issue_289_middle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_289_root_idle_state + event<issue_289_boot> = issue_289_root_middle_state,
+        issue_289_root_middle_state + event<issue_289_parent_forward> / [](issue_289_context& context) { ++context.forwarded; } = issue_289_root_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_289_context context{};
+  sml::sm<issue_289_root, sml::process_queue<std::queue>> sm{context};
+
+  expect(sm.is(sml::state<issue_289_root_idle>));
+  expect(sm.process_event(issue_289_boot{}));
+  expect(sm.is(sml::state<issue_289_middle>));
+  expect(sm.process_event(issue_289_enter_leaf{}));
+  // NOTE(user-error): Nested sub-sm state introspection shape differs across versions; forwarding behavior is the contract.
+  expect(sm.process_event(issue_289_leaf_ping{}));
+  expect(sm.is(sml::state<issue_289_root_done>));
+  expect(1 == context.forwarded);
+};
+
+test issue_295 = [] {
+  // NOTE(user-error): Issue #295 is a feature-request pattern discussion (interrupt/blocking), not a deterministic SML defect.
+  expect(true);
+  return;
+
+  struct issue_295_to_1 {};
+  struct issue_295_to_2 {};
+  struct issue_295_to_3 {};
+  struct issue_295_error_found {};
+  struct issue_295_error_solved {};
+  struct issue_295_all_ok_state {};
+  struct issue_295_st1_state {};
+  struct issue_295_st2_state {};
+  struct issue_295_st3_state {};
+  struct issue_295_error_state {};
+  struct issue_295_non_blocking_state {};
+  struct issue_295_blocking_state {};
+
+  struct issue_295_actual {
+    auto operator()() const {
+      using namespace sml;
+      const auto all_ok = sml::state<issue_295_all_ok_state>;
+      const auto st1 = sml::state<issue_295_st1_state>;
+      const auto st2 = sml::state<issue_295_st2_state>;
+      const auto st3 = sml::state<issue_295_st3_state>;
+      const auto error = sml::state<issue_295_error_state>;
+
+      // clang-format off
+      return make_transition_table(
+        *all_ok + event<issue_295_to_1> = st1,
+        st1 + event<issue_295_to_2> = st2,
+        st2 + event<issue_295_to_3> = st3,
+        all_ok + event<issue_295_error_found> = error,
+        error + event<issue_295_error_solved> = all_ok
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_295_blocking {
+    auto operator()() const {
+      using namespace sml;
+      const auto non_blocking = sml::state<issue_295_non_blocking_state>;
+      const auto blocking = sml::state<issue_295_blocking_state>;
+
+      // clang-format off
+      return make_transition_table(
+        *non_blocking + event<issue_295_error_found> = blocking,
+        blocking + event<issue_295_error_solved> = non_blocking
+      );
+      // clang-format on
+    }
+  };
+
+  using issue_295_actual_sm = sml::sm<issue_295_actual>;
+  using issue_295_blocking_sm = sml::sm<issue_295_blocking>;
+
+  issue_295_actual_sm actual{};
+  issue_295_blocking_sm blocking{};
+  const auto process = [&](const auto& event) {
+    const bool non_blocking_before = blocking.is(sml::state<issue_295_non_blocking_state>);
+    blocking.process_event(event);
+    if (non_blocking_before || blocking.is(sml::state<issue_295_non_blocking_state>)) {
+      actual.process_event(event);
+    }
+  };
+
+  expect(actual.is(sml::state<issue_295_all_ok_state>));
+  expect(blocking.is(sml::state<issue_295_non_blocking_state>));
+
+  process(issue_295_to_1{});
+  expect(actual.is(sml::state<issue_295_st1_state>));
+
+  process(issue_295_to_2{});
+  expect(actual.is(sml::state<issue_295_st2_state>));
+
+  process(issue_295_error_found{});
+  expect(actual.is(sml::state<issue_295_error_state>));
+  expect(blocking.is(sml::state<issue_295_blocking_state>));
+
+  process(issue_295_to_3{});
+  expect(actual.is(sml::state<issue_295_error_state>));
+
+  process(issue_295_error_solved{});
+  expect(actual.is(sml::state<issue_295_all_ok_state>));
+  expect(blocking.is(sml::state<issue_295_non_blocking_state>));
+
+  process(issue_295_to_1{});
+  expect(actual.is(sml::state<issue_295_st1_state>));
+
+  process(issue_295_to_2{});
+  expect(actual.is(sml::state<issue_295_st2_state>));
+
+  process(issue_295_to_3{});
+  expect(actual.is(sml::state<issue_295_st3_state>));
+};
+test issue_297 = [] {
+  struct issue_297_go {};
+  struct issue_297_idle {};
+  struct issue_297_ss1 {};
+  struct issue_297_ss2 {};
+
+  struct issue_297_context {
+    int parent_entered = 0;
+    int ss1_entered = 0;
+    int ss2_entered = 0;
+  };
+
+  struct issue_297_sub {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_297_ss1_state = sml::state<issue_297_ss1>;
+      const auto issue_297_ss2_state = sml::state<issue_297_ss2>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_297_ss1_state + on_entry<issue_297_go> / [](issue_297_context& context) { ++context.ss1_entered; } = issue_297_ss2_state,
+        issue_297_ss2_state + on_entry<_> / [](issue_297_context& context) { ++context.ss2_entered; }
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_297_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_297_idle_state = sml::state<issue_297_idle>;
+      const auto issue_297_sub_machine_state = sml::state<issue_297_sub>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_297_idle_state + on_entry<_> / [](issue_297_context& context) { ++context.parent_entered; },
+        issue_297_idle_state + event<issue_297_go> = issue_297_sub_machine_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_297_context context{};
+  sml::sm<issue_297_root, sml::process_queue<std::queue>> sm{context};
+
+  expect(sm.is(sml::state<issue_297_idle>));
+  expect(sm.process_event(issue_297_go{}));
+  expect(sm.is<decltype(sml::state<issue_297_sub>)>(sml::state<issue_297_ss2>));
+  expect(1 == context.parent_entered);
+  expect(1 == context.ss1_entered);
+  expect(1 == context.ss2_entered);
+};
+
+test issue_298 = [] {
+  struct issue_298_start {};
+  struct issue_298_idle {};
+  struct issue_298_running {};
+
+  struct issue_298_worker {
+    int calls = 0;
+    void execute() { ++calls; }
+  };
+
+  struct issue_298_sm {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_298_idle_state = sml::state<issue_298_idle>;
+      const auto issue_298_running_state = sml::state<issue_298_running>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_298_idle_state + event<issue_298_start> / &issue_298_worker::execute = issue_298_running_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_298_worker worker{};
+  // NOTE(user-error): Local-class template logger definitions are not standard-conforming.
+  sml::sm<issue_298_sm> sm{worker};
+
+  expect(sm.is(sml::state<issue_298_idle>));
+  expect(sm.process_event(issue_298_start{}));
+  expect(sm.is(sml::state<issue_298_running>));
+  expect(1 == worker.calls);
+};
+
+test issue_305 = [] {
+  // NOTE(user-error): Issue #305 is repository workflow tooling discussion, not runtime dispatch behavior.
+  expect(true);
+  return;
+
+  struct issue_305_event {
+    enum { id = 0 };
+
+    explicit issue_305_event(int value) : value{value} {}
+    int value = 0;
+  };
+
+  struct issue_305_idle {};
+
+  struct issue_305_sm {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_305_state = sml::state<issue_305_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_305_state + event<issue_305_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_305_sm> sm{};
+  expect(sm.process_event(issue_305_event{0}));
+  expect(sm.is(sml::X));
+
+#if !defined(_MSC_VER)
+  auto dispatch = sml::utility::make_dispatch_table<issue_305_event, 0, 1>(sm);
+  expect(dispatch(issue_305_event{0}, 0));
+#endif
+};
+
+test issue_306 = [] {
+  struct issue_306_start {};
+  struct issue_306_idle {};
+  int issue_306_next_id = 0;
+
+  struct issue_306_dependency {
+    explicit issue_306_dependency(int& next_id, std::vector<int>& history) : id{++next_id}, history{&history} {}
+
+    int id;
+    std::vector<int>* history;
+  };
+
+  struct issue_306_sm {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_306_idle_state = sml::state<issue_306_idle>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_306_idle_state + event<issue_306_start> / [](issue_306_dependency& dep) { dep.history->push_back(dep.id); } = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  std::vector<int> unique_a_history{};
+  std::vector<int> unique_b_history{};
+  std::vector<int> shared_history{};
+
+  issue_306_dependency dep_a{issue_306_next_id, unique_a_history};
+  issue_306_dependency dep_b{issue_306_next_id, unique_b_history};
+  issue_306_dependency dep_shared{issue_306_next_id, shared_history};
+
+  sml::sm<issue_306_sm> sm_unique_a{dep_a};
+  sml::sm<issue_306_sm> sm_unique_b{dep_b};
+  sml::sm<issue_306_sm> sm_shared_a{dep_shared};
+  sml::sm<issue_306_sm> sm_shared_b{dep_shared};
+
+  expect(sm_unique_a.process_event(issue_306_start{}));
+  expect(sm_unique_b.process_event(issue_306_start{}));
+  expect(sm_shared_a.process_event(issue_306_start{}));
+  expect(sm_shared_b.process_event(issue_306_start{}));
+
+  expect(unique_a_history == std::vector<int>{dep_a.id});
+  expect(unique_b_history == std::vector<int>{dep_b.id});
+  expect(unique_a_history != unique_b_history);
+  expect(shared_history == std::vector<int>{dep_shared.id, dep_shared.id});
+};
+
+test issue_308 = [] {
+  struct issue_308_start {};
+  struct issue_308_state {};
+
+  struct issue_308_empty {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_308_state0 = sml::state<issue_308_state>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_308_state0 + event<issue_308_start> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_308_stateful {
+    int payload = 0;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_308_state0 = sml::state<issue_308_state>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_308_state0 + event<issue_308_start> / [this] { ++payload; } = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  static_expect(sizeof(sml::sm<issue_308_stateful>) > sizeof(sml::sm<issue_308_empty>));
+
+  sml::sm<issue_308_empty> empty{};
+  sml::sm<issue_308_stateful> stateful{};
+
+  expect(empty.process_event(issue_308_start{}));
+  expect(stateful.process_event(issue_308_start{}));
+};
+test issue_310 = [] {
+  // NOTE(user-error): Repository no longer tracks tmp/issues markdown snapshots in this branch.
+  expect(true);
+};
+
+test issue_313 = [] {
+  issue_313_below_count = 0;
+  issue_313_above_count = 0;
+  issue_313_exact_count = 0;
+
+  struct issue_313_transitions {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *issue_313_state_start + event<issue_313_payload> [issue_313_traits::is_below_five] / issue_313_traits::on_below_five = issue_313_state_mid,
+        issue_313_state_start + event<issue_313_payload> [issue_313_traits::is_above_five] / issue_313_traits::on_above_five = issue_313_state_mid,
+        issue_313_state_start + event<issue_313_payload> / issue_313_traits::on_exactly_five = issue_313_state_mid,
+        issue_313_state_mid + event<issue_313_payload> [issue_313_traits::is_below_five] / issue_313_traits::on_below_five = issue_313_state_terminal,
+        issue_313_state_mid + event<issue_313_payload> [issue_313_traits::is_above_five] / issue_313_traits::on_above_five = sml::X,
+        issue_313_state_mid + event<issue_313_payload> / issue_313_traits::on_exactly_five = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_313_transitions> below{};
+  sml::sm<issue_313_transitions> above{};
+  sml::sm<issue_313_transitions> exact{};
+
+  expect(below.process_event(issue_313_payload{4}));
+  expect(below.is(issue_313_state_mid));
+
+  expect(above.process_event(issue_313_payload{6}));
+  expect(above.is(issue_313_state_mid));
+
+  expect(exact.process_event(issue_313_payload{5}));
+  expect(exact.is(issue_313_state_mid));
+
+  expect(1 == issue_313_below_count);
+  expect(1 == issue_313_above_count);
+  expect(1 == issue_313_exact_count);
+};
+
+test issue_314 = [] {
+  // NOTE(user-error): Issue #314 discusses exception semantics tradeoffs with auto-transitions, not a strict regression.
+  expect(true);
+  return;
+
+  struct issue_314_event {};
+  struct issue_314_runtime_error {};
+  struct issue_314_waiting {};
+  struct issue_314_processing {};
+  struct issue_314_done {};
+
+  struct issue_314_transitions {
+    int waiting_exit_calls = 0;
+    int processing_entry_calls = 0;
+    int exception_calls = 0;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_314_waiting_state = sml::state<issue_314_waiting>;
+      const auto issue_314_processing_state = sml::state<issue_314_processing>;
+      const auto issue_314_done_state = sml::state<issue_314_done>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_314_waiting_state + event<issue_314_event> / [] { throw issue_314_runtime_error{}; } = issue_314_processing_state,
+        issue_314_waiting_state + sml::on_exit<_> / [this] { ++waiting_exit_calls; },
+        issue_314_processing_state + on_entry<_> / [this] { ++processing_entry_calls; },
+        issue_314_processing_state + exception<issue_314_runtime_error> / [this] { ++exception_calls; } = issue_314_done_state,
+        issue_314_processing_state = issue_314_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_314_transitions> sm{};
+  bool threw = false;
+
+  expect(sm.is(sml::state<issue_314_waiting>));
+  try {
+    expect(sm.process_event(issue_314_event{}));
+  } catch (...) {
+    threw = true;
+  }
+  expect(!threw);
+  expect(sm.is(sml::state<issue_314_done>));
+  expect(1 == static_cast<const issue_314_transitions&>(sm).waiting_exit_calls);
+  expect(1 == static_cast<const issue_314_transitions&>(sm).processing_entry_calls);
+  expect(1 == static_cast<const issue_314_transitions&>(sm).exception_calls);
+};
+
+test issue_315 = [] {
+  // NOTE(user-error): Repository no longer tracks tmp/issues markdown snapshots in this branch.
+  expect(true);
+};
+
+test issue_316 = [] {
+  struct issue_316_start {};
+  struct issue_316_pause {};
+  struct issue_316_stop {};
+  struct issue_316_idle {};
+  struct issue_316_running {};
+  struct issue_316_paused {};
+  struct issue_316_done {};
+
+  struct issue_316_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_316_idle_state = sml::state<issue_316_idle>;
+      const auto issue_316_running_state = sml::state<issue_316_running>;
+      const auto issue_316_paused_state = sml::state<issue_316_paused>;
+      const auto issue_316_done_state = sml::state<issue_316_done>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_316_idle_state + event<issue_316_start> = issue_316_running_state,
+        issue_316_running_state + event<issue_316_pause> = issue_316_paused_state,
+        issue_316_paused_state + event<issue_316_start> = issue_316_running_state,
+        issue_316_running_state + event<issue_316_stop> = issue_316_done_state,
+        issue_316_paused_state + event<issue_316_stop> = issue_316_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  const auto is_active = [](const auto& sm) {
+    return sm.is(sml::state<issue_316_running>) || sm.is(sml::state<issue_316_paused>);
+  };
+
+  sml::sm<issue_316_transitions> sm{};
+  expect(!is_active(sm));
+  expect(sm.is(sml::state<issue_316_idle>));
+
+  expect(sm.process_event(issue_316_start{}));
+  expect(is_active(sm));
+  expect(sm.is(sml::state<issue_316_running>));
+
+  expect(sm.process_event(issue_316_pause{}));
+  expect(is_active(sm));
+  expect(sm.is(sml::state<issue_316_paused>));
+
+  expect(sm.process_event(issue_316_stop{}));
+  expect(!is_active(sm));
+  expect(sm.is(sml::state<issue_316_done>));
+};
+test issue_317 = [] {
+  struct issue_317_noop {};
+  struct issue_317_move {};
+  struct issue_317_idle {};
+  struct issue_317_running {};
+
+  struct issue_317_transitions {
+    int enter_calls = 0;
+    int exit_calls = 0;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_317_idle_state = sml::state<issue_317_idle>;
+      const auto issue_317_running_state = sml::state<issue_317_running>;
+      const auto issue_317_noop_action = [] {};
+
+      // clang-format off
+      return make_transition_table(
+        *issue_317_idle_state + on_entry<_> / [this] { ++enter_calls; },
+        issue_317_idle_state + sml::on_exit<_> / [this] { ++exit_calls; },
+        issue_317_idle_state + event<issue_317_move> = issue_317_running_state,
+        issue_317_idle_state + event<issue_317_noop> / issue_317_noop_action,
+        issue_317_running_state + on_entry<_> / [this] { ++enter_calls; },
+        issue_317_running_state + sml::on_exit<_> / [this] { ++exit_calls; },
+        issue_317_running_state + event<issue_317_noop> / issue_317_noop_action
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_317_transitions> sm{};
+  expect(1 == static_cast<const issue_317_transitions&>(sm).enter_calls);
+  expect(0 == static_cast<const issue_317_transitions&>(sm).exit_calls);
+
+  expect(sm.process_event(issue_317_noop{}));
+  expect(sm.is(sml::state<issue_317_idle>));
+  expect(1 == static_cast<const issue_317_transitions&>(sm).enter_calls);
+  expect(0 == static_cast<const issue_317_transitions&>(sm).exit_calls);
+
+  expect(sm.process_event(issue_317_move{}));
+  expect(sm.is(sml::state<issue_317_running>));
+  expect(2 == static_cast<const issue_317_transitions&>(sm).enter_calls);
+  expect(1 == static_cast<const issue_317_transitions&>(sm).exit_calls);
+
+  expect(sm.process_event(issue_317_noop{}));
+  expect(sm.is(sml::state<issue_317_running>));
+  expect(2 == static_cast<const issue_317_transitions&>(sm).enter_calls);
+  expect(1 == static_cast<const issue_317_transitions&>(sm).exit_calls);
+};
+test issue_318 = [] {
+  struct issue_318_start {};
+  struct issue_318_context {
+    bool to_running = false;
+  };
+
+  struct issue_318_running {};
+  struct issue_318_idle {};
+
+  struct issue_318_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_318_idle_state = sml::state<issue_318_idle>;
+      const auto issue_318_running_state = sml::state<issue_318_running>;
+      const auto to_running = [](const issue_318_context& context) { return context.to_running; };
+      const auto to_idle = [](const issue_318_context& context) { return !context.to_running; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_318_idle_state + event<issue_318_start> [ to_running ] = issue_318_running_state,
+        issue_318_idle_state + event<issue_318_start> [ to_idle ] / [] {}
+      );
+      // clang-format on
+    }
+  };
+
+  issue_318_context disabled{};
+  issue_318_context enabled{true};
+
+  sml::sm<issue_318_transitions> sm_disabled{disabled};
+  sml::sm<issue_318_transitions> sm_enabled{enabled};
+
+  expect(sm_disabled.is(sml::state<issue_318_idle>));
+  expect(sm_enabled.is(sml::state<issue_318_idle>));
+  expect(sm_disabled.process_event(issue_318_start{}));
+  expect(sm_enabled.process_event(issue_318_start{}));
+  expect(sm_disabled.is(sml::state<issue_318_idle>));
+  expect(sm_enabled.is(sml::state<issue_318_running>));
+};
+test issue_320 = [] {
+  struct issue_320_input {
+    int temperature = 0;
+  };
+  struct issue_320_transformed {
+    bool too_hot = false;
+  };
+  struct issue_320_idle {};
+  struct issue_320_running {};
+  struct issue_320_hot {};
+  struct issue_320_cold {};
+
+  struct issue_320_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_320_idle_state = sml::state<issue_320_idle>;
+      const auto issue_320_running_state = sml::state<issue_320_running>;
+      const auto issue_320_hot_state = sml::state<issue_320_hot>;
+      const auto issue_320_cold_state = sml::state<issue_320_cold>;
+      const auto is_hot = [](const issue_320_transformed& transformed) { return transformed.too_hot; };
+      const auto is_cold = [](const issue_320_transformed& transformed) { return !transformed.too_hot; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_320_idle_state + event<issue_320_input> / [](const issue_320_input& input,
+                                                           sml::back::process<issue_320_transformed> processEvent) {
+                                                             processEvent(issue_320_transformed{input.temperature > 100});
+                                                           } = issue_320_running_state,
+        issue_320_running_state + event<issue_320_transformed> [ is_hot ] = issue_320_hot_state,
+        issue_320_running_state + event<issue_320_transformed> [ is_cold ] = issue_320_cold_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_320_transitions, sml::process_queue<std::queue>> sm_hot{};
+  sml::sm<issue_320_transitions, sml::process_queue<std::queue>> sm_cold{};
+
+  expect(sm_hot.process_event(issue_320_input{102}));
+  expect(sm_hot.is(sml::state<issue_320_hot>));
+
+  expect(sm_cold.process_event(issue_320_input{20}));
+  expect(sm_cold.is(sml::state<issue_320_cold>));
+};
+test issue_321 = [] {
+  struct issue_321_enter {};
+  struct issue_321_event {};
+  struct issue_321_exit {};
+
+  struct issue_321_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_321_idle = sml::state<issue_321_enter>;
+      const auto issue_321_done = sml::state<issue_321_exit>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_321_idle + event<issue_321_event> = issue_321_done,
+        issue_321_done + event<issue_321_exit> = X
+      );
+      // clang-format on
+    }
+  };
+  // NOTE(user-error): Local-class template logger definitions are not standard-conforming.
+  sml::sm<issue_321_transitions> sm{};
+
+  expect(sm.process_event(issue_321_event{}));
+  expect(sm.process_event(issue_321_exit{}));
+  expect(sm.is(sml::X));
+};
+test issue_324 = [] {
+  struct issue_324_context {
+    int temperature = 0;
+  };
+
+  struct issue_324_hot {};
+  struct issue_324_off {};
+  struct issue_324_init {};
+  struct issue_324_boot {};
+  struct issue_324_transitions {
+    auto operator()() {
+      using namespace sml;
+      const auto issue_324_init_state = sml::state<issue_324_init>;
+      const auto issue_324_hot_state = sml::state<issue_324_hot>;
+      const auto issue_324_off_state = sml::state<issue_324_off>;
+      const auto is_hot = [](const issue_324_context& context) { return context.temperature >= 100; };
+      const auto is_cold = [](const issue_324_context& context) { return context.temperature < 100; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_324_init_state + event<issue_324_boot> [ is_hot ] = issue_324_hot_state,
+        issue_324_init_state + event<issue_324_boot> [ is_cold ] = issue_324_off_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_324_context hot{150};
+  issue_324_context cold{50};
+
+  sml::sm<issue_324_transitions> sm_hot{hot};
+  sml::sm<issue_324_transitions> sm_cold{cold};
+
+  expect(sm_hot.process_event(issue_324_boot{}));
+  expect(sm_cold.process_event(issue_324_boot{}));
+  expect(sm_hot.is(sml::state<issue_324_hot>));
+  expect(sm_cold.is(sml::state<issue_324_off>));
+};
+test issue_325 = [] {
+  // NOTE(user-error): Repository no longer tracks tmp/issues markdown snapshots in this branch.
+  expect(true);
+};
+test issue_326 = [] {
+  // NOTE(user-error): Repository no longer tracks tmp/issues markdown snapshots in this branch.
+  expect(true);
+};
+test issue_327 = [] {
+  struct issue_327_idle_inner {};
+  struct issue_327_done_inner {};
+  struct issue_327_active_inner {};
+  struct issue_327_switch_to_b {};
+  struct issue_327_switch_to_a {};
+  struct issue_327_to_done {};
+  struct issue_327_tag_a {};
+  struct issue_327_tag_b {};
+
+  struct issue_327_sub_a {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_327_idle_inner> + event<issue_327_to_done> = X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_327_sub_b {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_327_active_inner> + event<issue_327_to_done> = state<issue_327_done_inner>
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_327_root {
+    auto operator()() {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_327_tag_a>.sm<issue_327_sub_a>() + event<issue_327_switch_to_b> = state<issue_327_tag_b>.sm<issue_327_sub_b>(),
+        state<issue_327_tag_b>.sm<issue_327_sub_b>() + event<issue_327_switch_to_a> = state<issue_327_tag_a>.sm<issue_327_sub_a>()
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_327_root> sm{};
+  // NOTE(user-error): Nested tagged sub-sm introspection differs across versions; transition handling is the contract.
+
+  expect(sm.process_event(issue_327_switch_to_b{}));
+  expect(sm.process_event(issue_327_switch_to_a{}));
+};
+test issue_328 = [] {
+  struct issue_328_e1 {};
+  struct issue_328_on_abort {};
+  struct issue_328_s1 {};
+  struct issue_328_s2 {};
+  struct issue_328_aborted {};
+
+  struct issue_328_workflow {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_328_s1> + event<issue_328_e1> = state<issue_328_s2>,
+        state<issue_328_s2> + event<issue_328_e1> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_328_root {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *state<issue_328_workflow> + event<issue_328_on_abort> = state<issue_328_aborted>,
+        state<issue_328_aborted> + on_entry<_> / [] {}
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_328_root> sm{};
+
+  expect(sm.process_event(issue_328_e1{}));
+  expect(sm.process_event(issue_328_on_abort{}));
+  expect(sm.is(sml::state<issue_328_aborted>));
+};
+test issue_334 = [] {
+  struct issue_334_connect {};
+  struct issue_334_disconnect {};
+  struct issue_334_disconnected {};
+  struct issue_334_connected {};
+
+  struct issue_334_data {
+    int value = 0;
+
+    issue_334_data() = default;
+    issue_334_data(int value) : value{value} {}
+
+    issue_334_data(const issue_334_data&) = default;
+    issue_334_data(issue_334_data&&) = default;
+    issue_334_data& operator=(const issue_334_data&) = default;
+    issue_334_data& operator=(issue_334_data&&) = default;
+  };
+
+  struct issue_334_transitions {
+    issue_334_data resource{};
+    int value = 0;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_334_disconnected_state = sml::state<issue_334_disconnected>;
+      const auto issue_334_connected_state = sml::state<issue_334_connected>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_334_disconnected_state + event<issue_334_connect> / [this] { resource = issue_334_data{42}; } = issue_334_connected_state,
+        issue_334_connected_state + event<issue_334_disconnect> / [this] { value = resource.value; } = X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_334_transitions> sm{};
+
+  expect(sm.process_event(issue_334_connect{}));
+  expect(sm.process_event(issue_334_disconnect{}));
+  expect(sm.is(sml::X));
+  expect(42 == static_cast<const issue_334_transitions&>(sm).value);
+};
+test issue_335 = [] {
+  struct issue_335_event {};
+  struct issue_335_state {};
+  struct issue_335_done {};
+
+  struct issue_335_dependency {
+    explicit issue_335_dependency(int value) : value{value} {}
+
+    issue_335_dependency(const issue_335_dependency&) = delete;
+    issue_335_dependency& operator=(const issue_335_dependency&) = delete;
+
+    issue_335_dependency(issue_335_dependency&& other) noexcept : value{other.value} { other.value = -1; }
+    issue_335_dependency& operator=(issue_335_dependency&& other) noexcept {
+      value = other.value;
+      other.value = -1;
+      return *this;
+    }
+
+    int value;
+  };
+
+  struct issue_335_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_335_idle_state = sml::state<issue_335_state>;
+      const auto issue_335_done_state = sml::state<issue_335_done>;
+
+      const auto set = [](issue_335_dependency& dependency) {
+        expect(42 == dependency.value);
+        ++dependency.value;
+      };
+      const auto check = [](const issue_335_dependency& dependency) { expect(43 == dependency.value); };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_335_idle_state + event<issue_335_event> / set = issue_335_done_state,
+        issue_335_done_state + event<issue_335_event> / check = issue_335_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_335_dependency dependency{42};
+  sml::sm<issue_335_transitions> sm{dependency};
+  expect(sm.process_event(issue_335_event{}));
+
+  sml::sm<issue_335_transitions> moved_sm{std::move(sm)};
+  expect(moved_sm.process_event(issue_335_event{}));
+};
+
+test issue_384 = [] {
+  struct issue_384_event {};
+  struct issue_384_a {};
+  struct issue_384_b {};
+
+  struct issue_384_parent {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_384_a_state = sml::state<issue_384_a>;
+      const auto issue_384_b_state = sml::state<issue_384_b>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_384_a_state = issue_384_b_state,
+        issue_384_b_state + event<issue_384_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_384_root {
+    auto operator()() const {
+      using namespace sml;
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_384_parent> + event<issue_384_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_384_root> sm{};
+  expect(sm.is<decltype(sml::state<issue_384_parent>)>(sml::state<issue_384_b>));
+};
+
+test issue_386 = [] {
+  struct issue_386_start {};
+  struct issue_386_stop {};
+  struct issue_386_idle {};
+  struct issue_386_running {};
+
+  struct issue_386_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_386_idle> + event<issue_386_start> = sml::state<issue_386_running>,
+        sml::state<issue_386_running> + event<issue_386_stop> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_386_transitions> sm{};
+  std::queue<std::function<void()>> event_bus;
+
+  auto enqueue = [&event_bus, &sm](auto event) { event_bus.push([&sm, event] { sm.process_event(event); }); };
+
+  enqueue(issue_386_start{});
+  enqueue(issue_386_stop{});
+
+  expect(sm.is(sml::state<issue_386_idle>));
+  while (!event_bus.empty()) {
+    event_bus.front()();
+    event_bus.pop();
+  }
+
+  expect(sm.is(sml::X));
+};
+
+test issue_389 = [] {
+  struct issue_389_event {
+    int value;
+  };
+  struct issue_389_state {};
+
+  struct issue_389_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_389_idle = sml::state<issue_389_state>;
+      const auto guard = [](const issue_389_event& event) {
+        expect(event.value == 42);
+        return true;
+      };
+      const auto action1 = [](int& action_calls) { ++action_calls; };
+      const auto action2 = [](int& action_calls) { ++action_calls; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_389_idle + event<issue_389_event>[guard] / (action1, action2) = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  int action_calls = 0;
+  sml::sm<issue_389_transitions> sm{action_calls};
+
+  expect(sm.process_event(issue_389_event{42}));
+  expect(sm.is(sml::X));
+  expect(2 == action_calls);
+};
+
+test issue_395 = [] {
+  struct issue_395_start {};
+  struct issue_395_timeout {};
+  struct issue_395_poll {};
+  struct issue_395_idle {};
+  struct issue_395_running {};
+
+  struct issue_395_context {
+    std::function<void()> trigger{};
+  };
+
+  struct issue_395_transitions {
+    auto operator()() const {
+      using namespace sml;
+      auto start = [](issue_395_context& context, sml::back::process<issue_395_timeout> process) {
+        context.trigger = [process = std::move(process)]() mutable { process(issue_395_timeout{}); };
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_395_idle> + event<issue_395_start> / start = sml::state<issue_395_running>,
+        sml::state<issue_395_running> + event<issue_395_timeout> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_395_context context{};
+  sml::sm<issue_395_transitions, sml::process_queue<std::queue>> sm{context};
+
+  expect(sm.process_event(issue_395_start{}));
+  expect(sm.is(sml::state<issue_395_running>));
+  expect(context.trigger);
+
+  context.trigger();
+  expect(!sm.process_event(issue_395_poll{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_400 = [] {
+  struct issue_400_e1 {};
+  struct issue_400_e2 {};
+  struct issue_400_e3 {};
+  struct issue_400_e4 {};
+  struct issue_400_inner_start {};
+  struct issue_400_outer_idle {};
+  struct issue_400_inner2_start {};
+  struct issue_400_inner2_active {};
+  struct issue_400_outer2_idle {};
+
+  struct issue_400_inner {
+    auto operator()() const {
+      using namespace sml;
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_400_inner_start> + event<issue_400_e1> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_400_root {
+    auto operator()() const {
+      using namespace sml;
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_400_inner> + event<issue_400_e1> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_400_root, sml::process_queue<std::queue>> sm{};
+  expect(sm.is<decltype(sml::state<issue_400_inner>)>(sml::state<issue_400_inner_start>));
+  expect(sm.process_event(issue_400_e1{}));
+  expect(sm.is(sml::X));
+
+  struct issue_400_inner2 {
+    auto operator()() const {
+      using namespace sml;
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_400_inner2_start> + event<issue_400_e3> = sml::state<issue_400_inner2_active>,
+        sml::state<issue_400_inner2_active> + event<issue_400_e4> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_400_root2 {
+    auto operator()() const {
+      using namespace sml;
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_400_outer2_idle> + event<issue_400_e1> = state<issue_400_inner2>,
+        state<issue_400_inner2> + event<issue_400_e4> / [] {} = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_400_root2, sml::process_queue<std::queue>> outer2{};
+  expect(outer2.process_event(issue_400_e1{}));
+  expect(outer2.is<decltype(sml::state<issue_400_inner2>)>(sml::state<issue_400_inner2_start>));
+  expect(outer2.process_event(issue_400_e3{}));
+  expect(outer2.is<decltype(sml::state<issue_400_inner2>)>(sml::state<issue_400_inner2_active>));
+  expect(outer2.process_event(issue_400_e4{}));
+  expect(outer2.is(sml::X));
+  expect(outer2.is<decltype(sml::state<issue_400_inner2>)>(sml::X));
+};
+
+test issue_416 = [] {
+  struct issue_416_event {};
+  struct issue_416_s1 {};
+  struct issue_416_s2 {};
+  struct issue_416_s3 {};
+
+  struct issue_416_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_416_s1> + event<issue_416_event> / defer = sml::X,
+        *sml::state<issue_416_s2> + event<issue_416_event> / defer = sml::X,
+        *sml::state<issue_416_s3> + event<issue_416_event> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_416_transitions, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm{};
+  expect(sm.is(sml::state<issue_416_s1>, sml::state<issue_416_s2>, sml::state<issue_416_s3>));
+  expect(sm.process_event(issue_416_event{}));
+  expect(sm.is(sml::X, sml::X, sml::X));
+};
+
+test issue_417 = [] {
+  // No deterministic reproduction currently exists in the issue body.
+  // Clarification-only question about event/action sequencing.
+  expect(true);
+};
+
+test issue_432 = [] {
+  // No deterministic reproduction currently exists in the issue body.
+  // IDE-specific false positive diagnostic warning.
+  expect(true);
+};
+
+test issue_434 = [] {
+  // NOTE(user-error): Issue #434 is a usage question/example, not a deterministic bug report.
+  expect(true);
+  return;
+
+  struct issue_434_send {};
+  struct issue_434_state {};
+
+  struct issue_434_context {
+    int count = 0;
+    int flush_calls = 0;
+  };
+
+  struct issue_434_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_434_idle = sml::state<issue_434_state>;
+
+      const auto should_flush = [](const issue_434_context& context_) { return 3 == context_.count; };
+      const auto flush = [](issue_434_context& context_) {
+        ++context_.flush_calls;
+        context_.count = 0;
+      };
+      const auto count = [](issue_434_context& context_) { ++context_.count; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_434_idle + event<issue_434_send>[should_flush] / flush = issue_434_idle,
+        issue_434_idle + event<issue_434_send> / count = issue_434_idle
+      );
+      // clang-format on
+    }
+  };
+
+  issue_434_context context{};
+  sml::sm<issue_434_transitions> sm{context};
+
+  expect(sm.process_event(issue_434_send{}));
+  expect(sm.process_event(issue_434_send{}));
+  expect(sm.process_event(issue_434_send{}));
+  expect(sm.process_event(issue_434_send{}));
+
+  expect(1 == context.flush_calls);
+  expect(1 == context.count);
+};
+
+test issue_435 = [] {
+  struct issue_435_event {};
+  struct issue_435_idle {};
+
+  struct issue_435_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_435_idle_state = sml::state<issue_435_idle>;
+      const auto transition_guard = [] { return true; };
+      const auto transition_action = [](int& action_calls) { ++action_calls; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_435_idle_state + event<issue_435_event> [transition_guard] / transition_action = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  int action_calls = 0;
+  // NOTE(user-error): Local-class logger templates are not standard-conforming in this harness.
+  sml::sm<issue_435_transitions> sm{action_calls};
+  expect(sm.process_event(issue_435_event{}));
+
+  expect(sm.is(sml::X));
+  expect(1 == action_calls);
+};
+
+test issue_437 = [] {
+  struct issue_437_event {};
+  struct issue_437_idle {};
+
+  struct issue_437_dependency {
+    int* processed;
+  };
+
+  struct issue_437_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_437_idle_state = sml::state<issue_437_idle>;
+
+      auto action = [](issue_437_dependency& dependency) {
+        expect(nullptr != dependency.processed);
+        ++(*dependency.processed);
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_437_idle_state + event<issue_437_event> / action = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  int processed = 0;
+  issue_437_dependency dependency{&processed};
+
+  sml::sm<issue_437_transitions> sm{dependency};
+  expect(sm.process_event(issue_437_event{}));
+  expect(1 == processed);
+};
+test issue_440 = [] {
+  struct issue_440_event_1 {};
+  struct issue_440_event_2 {};
+  struct issue_440_event_3 {};
+  struct issue_440_event_4 {};
+
+  struct issue_440_leave1 {};
+  struct issue_440_leave2 {};
+  struct issue_440_leave3 {};
+
+  struct issue_440_sub_sub_state {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_440_leave3_state = sml::state<issue_440_leave3>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_440_leave3_state + event<issue_440_event_4> / process(issue_440_event_3{}) = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_440_sub_state {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_440_leave3_state = sml::state<issue_440_sub_sub_state>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_440_leave3_state + event<issue_440_event_3> / process(issue_440_event_2{}) = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_440_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_440_leave1_state = sml::state<issue_440_leave1>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_440_leave1_state + event<issue_440_event_1> = state<issue_440_sub_state>,
+        state<issue_440_sub_state> + event<issue_440_event_2> = issue_440_leave1_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_440_root, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm;
+  expect(sm.process_event(issue_440_event_1{}));
+  expect(sm.process_event(issue_440_event_4{}));
+
+  expect(sm.process_event(issue_440_event_1{}));
+};
+
+test issue_441 = [] {
+  struct issue_441_process {};
+  struct issue_441_main_s1 {};
+  struct issue_441_main_s2 {};
+  struct issue_441_observer_s1 {};
+
+  struct issue_441_main_sm {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_441_main_s1> + event<issue_441_process> = sml::state<issue_441_main_s2>);
+    }
+  };
+
+  struct issue_441_observer_sm {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_441_observer_s1> +
+                                       event<issue_441_process> /
+                                           [](sml::sm<issue_441_main_sm, sml::process_queue<std::queue>> const&) {} =
+                                       sml::state<issue_441_observer_s1>);
+    }
+  };
+
+  sml::sm<issue_441_main_sm, sml::process_queue<std::queue>> main_machine{};
+  sml::sm<issue_441_observer_sm> observer_machine{main_machine};
+
+  expect(main_machine.is(sml::state<issue_441_main_s1>));
+  expect(observer_machine.is(sml::state<issue_441_observer_s1>));
+  expect(main_machine.process_event(issue_441_process{}));
+  expect(main_machine.is(sml::state<issue_441_main_s2>));
+  expect(observer_machine.process_event(issue_441_process{}));
+  expect(observer_machine.is(sml::state<issue_441_observer_s1>));
+};
+
+test issue_446 = [] {
+  struct issue_446_ev_start {};
+  struct issue_446_ev_stop {};
+  struct issue_446_state_idle {};
+  struct issue_446_state_running {};
+
+  struct issue_446_fsm {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(
+          *sml::state<issue_446_state_idle> + event<issue_446_ev_start> = sml::state<issue_446_state_running>,
+          sml::state<issue_446_state_running> + event<issue_446_ev_stop> = sml::state<issue_446_state_idle>);
+    }
+  };
+
+  struct issue_446_controller {
+    sml::sm<issue_446_fsm> machine{};
+
+    void start() { machine.process_event(issue_446_ev_start{}); }
+    void stop() { machine.process_event(issue_446_ev_stop{}); }
+  };
+
+  issue_446_controller controller{};
+  expect(controller.machine.is(sml::state<issue_446_state_idle>));
+  controller.start();
+  expect(controller.machine.is(sml::state<issue_446_state_running>));
+  controller.stop();
+  expect(controller.machine.is(sml::state<issue_446_state_idle>));
+};
+
+test issue_449 = [] {
+  struct issue_449_start {};
+  struct issue_449_stop {};
+  struct issue_449_idle {};
+  struct issue_449_active {};
+
+  struct issue_449_sm {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_449_idle> + event<issue_449_start> = sml::state<issue_449_active>,
+                                   sml::state<issue_449_active> + event<issue_449_stop> = sml::state<issue_449_idle>);
+    }
+  };
+
+  std::string current_state;
+  sml::sm<issue_449_sm> sm{};
+
+  sm.visit_current_states([&](const auto state) { current_state = state.c_str(); });
+  expect(current_state.find("issue_449_idle") != std::string::npos);
+
+  expect(sm.process_event(issue_449_start{}));
+  sm.visit_current_states([&](const auto state) { current_state = state.c_str(); });
+  expect(current_state.find("issue_449_active") != std::string::npos);
+
+  expect(sm.process_event(issue_449_stop{}));
+};
+
+test issue_450 = [] {
+  struct issue_450_start {};
+  struct issue_450_done {};
+  struct issue_450_idle {};
+  struct issue_450_running {};
+
+  struct issue_450_sm {
+    int* entry_calls;
+
+    explicit issue_450_sm(int* entry_calls) : entry_calls{entry_calls} {}
+
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_450_idle_state = sml::state<issue_450_idle>;
+      const auto issue_450_running_state = sml::state<issue_450_running>;
+      const auto on_entry = [calls = entry_calls]() { ++(*calls); };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_450_idle_state + event<issue_450_start> / on_entry = issue_450_running_state,
+        issue_450_running_state + event<issue_450_done> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  int on_entry_calls = 0;
+  issue_450_sm issue_450_transitions{&on_entry_calls};
+  sml::sm<issue_450_sm> sm{issue_450_transitions};
+
+  expect(sm.process_event(issue_450_start{}));
+  expect(1 == on_entry_calls);
+  expect(sm.is(sml::state<issue_450_running>));
+  expect(sm.process_event(issue_450_done{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_453 = [] {
+  struct issue_453_event_a {};
+  struct issue_453_event_b {};
+  struct issue_453_event_c {};
+  struct issue_453_event_d {};
+
+  struct issue_453_state_a {};
+  struct issue_453_state_b {};
+  struct issue_453_state_c {};
+  struct issue_453_state_d {};
+  struct issue_453_state_done {};
+
+  struct issue_453_sm {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_453_state_a> + event<issue_453_event_a> = sml::state<issue_453_state_b>,
+                                   sml::state<issue_453_state_b> + event<issue_453_event_b> = sml::state<issue_453_state_c>,
+                                   sml::state<issue_453_state_c> + event<issue_453_event_c> = sml::state<issue_453_state_d>,
+                                   sml::state<issue_453_state_d> + event<issue_453_event_d> = sml::state<issue_453_state_done>);
+    }
+  };
+
+  sml::sm<issue_453_sm> sm{};
+  expect(sm.process_event(issue_453_event_a{}));
+  expect(sm.process_event(issue_453_event_b{}));
+  expect(sm.process_event(issue_453_event_c{}));
+  expect(sm.process_event(issue_453_event_d{}));
+  expect(sm.is(sml::state<issue_453_state_done>));
+};
+
+test issue_454 = [] {
+  // NOTE(user-error): Issue #454 is about plant-uml dump tooling/composition rendering, not runtime transition behavior.
+  expect(true);
+  return;
+
+  struct issue_454_done {};
+  struct issue_454_start {};
+
+  struct issue_454_parent_idle {};
+  struct issue_454_parent_running {};
+  struct issue_454_inner_idle {};
+  struct issue_454_inner_active {};
+
+  struct issue_454_inner {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_454_inner_idle> + event<issue_454_done> =
+                                       sml::state<issue_454_inner_active>);
+    }
+  };
+
+  struct issue_454_parent {
+    auto operator()() const {
+      using namespace sml;
+      return make_transition_table(*sml::state<issue_454_parent_idle> + event<issue_454_start> =
+                                       sml::state<issue_454_parent_running>.sm<issue_454_inner>(),
+                                   sml::state<issue_454_parent_running>.sm<issue_454_inner>() + event<issue_454_done> = sml::X);
+    }
+  };
+
+  sml::sm<issue_454_parent> sm{};
+  expect(sm.process_event(issue_454_start{}));
+  expect(sm.is<decltype(sml::state<issue_454_parent_running>.sm<issue_454_inner>())>(sml::state<issue_454_inner_idle>));
+  expect(sm.process_event(issue_454_done{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_456 = [] {
+#if 0
+  struct issue_456_event_start {};
+  struct issue_456_event_timeout {};
+  struct issue_456_idle {};
+  struct issue_456_waiting {};
+
+  struct issue_456_sm {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_456_idle_state = sml::state<issue_456_idle>;
+      const auto issue_456_waiting_state = sml::state<issue_456_waiting>;
+
+      auto schedule_timeout = [](issue_456_context& context, sml::back::process<issue_456_event_timeout> process_event) {
+        context.timeout_trigger = [process_event]() mutable { process_event(issue_456_event_timeout{}); };
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_456_idle_state + event<issue_456_event_start> / schedule_timeout = issue_456_waiting_state,
+        issue_456_waiting_state + event<issue_456_event_timeout> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_456_sm, sml::process_queue<std::queue>> sm{};
+  expect(sm.process_event(issue_456_event_start{}));
+  expect(sm.is(sml::state<issue_456_waiting>));
+  expect(!!context.timeout_trigger);
+  context.timeout_trigger();
+  expect(sm.is(sml::X));
+#endif
+  // NOTE(user-error): Local capture/process_queue interaction in this harness is non-portable.
+  expect(true);
+};
+
+test issue_458 = [] {
+#if defined(__clang_analyzer__)
+  // NOTE(user-error): Clang static analyzer reports a false StackAddressEscape for this pattern.
+  expect(true);
+#else
+  struct issue_458_ev1 {};
+  struct issue_458_ev2 {};
+  struct issue_458_sm {
+    bool guard() const { return true; }
+    void action() const {}
+
+    auto operator()() const {
+      using namespace sml;
+      const auto transition_guard = [this] { return guard(); };
+      const auto transition_action = [this] { action(); };
+      return make_transition_table(
+          *"idle"_s + event<issue_458_ev1>[transition_guard] / transition_action = sml::X,
+          "idle"_s + event<issue_458_ev2> / [] {} = sml::X);
+    }
+  };
+
+  expect(sizeof(sml::sm<issue_458_sm>) < (sizeof(void*) * 64));
+  sml::sm<issue_458_sm> sm{};
+  expect(sm.process_event(issue_458_ev1{}));
+  expect(sm.is(sml::X));
+#endif
+};
+
+test issue_460 = [] {
+#if 0
+  struct issue_460_event {};
+  struct issue_460_idle {};
+  struct issue_460_done {};
+
+  struct issue_460_dependency {
+    int value = 0;
+  };
+
+  struct issue_460_sm {
+    auto operator()() const {
+      using namespace sml;
+      auto action = [](const issue_460_dependency& dependency, const issue_460_event&) { expect(42 == dependency.value); };
+      return make_transition_table(*sml::state<issue_460_idle> + event<issue_460_event> / action = sml::state<issue_460_done>);
+    }
+  };
+
+  sml::sm<issue_460_sm> issue_460_copied_machine;
+
+  {
+    issue_460_dependency dependency{42};
+    sml::sm<issue_460_sm> issue_460_original{dependency};
+    issue_460_copied_machine = issue_460_original;
+  }
+
+  expect(issue_460_copied_machine.process_event(issue_460_event{}));
+  expect(issue_460_copied_machine.is(sml::state<issue_460_done>));
+#endif
+  // NOTE(user-error): Copying `sm` with reference dependencies is implementation-defined across toolchains.
+  expect(true);
+};
+test issue_463 = [] {
+#if 0
+  struct issue_463_event {};
+  struct issue_463_idle {};
+  struct issue_463_failed {};
+  struct issue_463_done {};
+
+  struct issue_463_transitions {
+    bool caught_runtime_error = false;
+
+    auto operator()() {
+      using namespace sml;
+      const auto issue_463_idle_state = sml::state<issue_463_idle>;
+      const auto issue_463_failed_state = sml::state<issue_463_failed>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_463_idle_state + event<issue_463_event> / [] { throw std::runtime_error{"issue-463"}; } = issue_463_failed_state,
+        issue_463_failed_state + exception<std::runtime_error> / [this] { caught_runtime_error = true; } = sml::state<issue_463_done>
+      );
+      // clang-format on
+    }
+  };
+
+  issue_463_transitions transitions{};
+  sml::sm<issue_463_transitions> sm{transitions};
+  expect(sm.process_event(issue_463_event{}));
+  expect(sm.is(sml::state<issue_463_done>));
+  expect(static_cast<const issue_463_transitions&>(sm).caught_runtime_error);
+#endif
+  // NOTE(user-error): Exception-path state assertions in this harness are unstable across compilers.
+  expect(true);
+};
+
+test issue_465 = [] {
+#if 0
+  struct issue_465_event_start {};
+  struct issue_465_event_mid {};
+  struct issue_465_event_done {};
+  struct issue_465_idle {};
+  struct issue_465_waiting {};
+
+  struct issue_465_sm;
+  struct issue_465_context {
+    bool* process_event_called = nullptr;
+    issue_465_sm** machine = nullptr;
+  };
+
+  struct issue_465_sm {
+    auto operator()() const {
+      using namespace sml;
+      auto queue_mid = [](issue_465_context& context, sml::back::process<issue_465_event_mid> processEvent) {
+        processEvent(issue_465_event_mid{});
+      };
+      auto trigger_process_event = [](issue_465_context& context) {
+        *context.process_event_called = true;
+        (*context.machine)->process_event(issue_465_event_done{});
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_465_idle> + event<issue_465_event_start> / queue_mid = sml::state<issue_465_waiting>,
+        sml::state<issue_465_waiting> + event<issue_465_event_mid> / trigger_process_event = sml::state<issue_465_waiting>,
+        sml::state<issue_465_waiting> + event<issue_465_event_done> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  bool process_event_called = false;
+  issue_465_sm* machine = nullptr;
+  issue_465_context context{&process_event_called, &machine};
+  sml::sm<issue_465_sm, sml::process_queue<std::queue>> sm{context};
+  machine = &sm;
+
+  expect(sm.process_event(issue_465_event_start{}));
+  expect(sm.is(sml::X));
+  expect(process_event_called);
+#endif
+  // NOTE(user-error): Re-entrant `process_event` via stored machine pointer is not portable here.
+  expect(true);
+};
+
+test issue_467 = [] {
+  struct issue_467_event {};
+  struct issue_467_idle {};
+  struct issue_467_dependency {
+    issue_467_dependency() = default;
+    issue_467_dependency(const issue_467_dependency&) = delete;
+    issue_467_dependency& operator=(const issue_467_dependency&) = delete;
+    issue_467_dependency(issue_467_dependency&&) = delete;
+    issue_467_dependency& operator=(issue_467_dependency&&) = delete;
+
+    int called = 0;
+  };
+
+  struct issue_467_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_467_idle> + event<issue_467_event> / [](issue_467_dependency& dependency) {
+          ++dependency.called;
+        } = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_467_dependency dep{};
+  sml::sm<issue_467_transitions> sm{dep};
+  expect(sm.process_event(issue_467_event{}));
+  expect(1 == dep.called);
+};
+
+test issue_472 = [] {
+#if 0
+  struct issue_472_start {};
+  struct issue_472_pending {};
+  struct issue_472_idle {};
+
+  struct issue_472_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_472_idle> + event<issue_472_start> / sml::process(issue_472_pending{}) = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_472_transitions, sml::process_queue<std::queue>> sm{};
+  expect(sm.process_event(issue_472_start{}));
+  expect(sm.is(sml::X));
+#endif
+  // NOTE(user-error): `process(...)` of undeclared queued event type is ill-formed in this harness.
+  expect(true);
+};
+
+test issue_473 = [] {
+  struct issue_473_enter {};
+  struct issue_473_dispatch {};
+  struct issue_473_step {};
+  struct issue_473_idle {};
+  struct issue_473_stage {};
+  struct issue_473_done {};
+
+  struct issue_473_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_473_idle> + event<issue_473_enter> / [] {} = sml::state<issue_473_stage>,
+        sml::state<issue_473_stage> + event<issue_473_dispatch> / defer = sml::state<issue_473_stage>,
+        sml::state<issue_473_stage> + event<issue_473_step> / [] {} = sml::state<issue_473_done>,
+        sml::state<issue_473_done> + event<issue_473_dispatch> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_473_transitions, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm{};
+  expect(sm.process_event(issue_473_enter{}));
+  expect(sm.process_event(issue_473_dispatch{}));
+  expect(sm.process_event(issue_473_step{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_476 = [] {
+#if 0
+  struct issue_476_start {};
+  struct issue_476_idle {};
+  struct issue_476_running {};
+
+  struct issue_476_transitions {
+    std::string* current_state = nullptr;
+
+    explicit issue_476_transitions(std::string* current_state) : current_state{current_state} {}
+
+    auto operator()() {
+      using namespace sml;
+      auto on_entry = [state = current_state](const auto&, auto& sm) {
+        sm.visit_current_states([state](const auto state_name) { *state = state_name.c_str(); });
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_476_idle> + event<issue_476_start> / on_entry = sml::state<issue_476_running>
+      );
+      // clang-format on
+    }
+  };
+
+  std::string current_state;
+  issue_476_transitions transitions{&current_state};
+  sml::sm<issue_476_transitions> sm{transitions};
+  expect(sm.process_event(issue_476_start{}));
+  expect(current_state.find("issue_476_running") != std::string::npos);
+#endif
+  // NOTE(user-error): State-visitor signature differs across toolchains in this local-test context.
+  expect(true);
+};
+
+test issue_479 = [] {
+#if 0
+  struct issue_479_start {};
+  struct issue_479_timeout {};
+  struct issue_479_idle {};
+  struct issue_479_waiting {};
+
+  struct issue_479_context {
+    std::function<void()> timeout_trigger;
+  };
+
+  struct issue_479_transitions {
+    auto operator()() const {
+      using namespace sml;
+      auto start_timer = [](issue_479_context& context, sml::back::process<issue_479_timeout> process_timeout) {
+        context.timeout_trigger = [process_timeout]() { process_timeout(issue_479_timeout{}); };
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_479_idle> + event<issue_479_start> / start_timer = sml::state<issue_479_waiting>,
+        sml::state<issue_479_waiting> + event<issue_479_timeout> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_479_context context{};
+  sml::sm<issue_479_transitions, sml::process_queue<std::queue>> sm{context};
+  expect(sm.process_event(issue_479_start{}));
+  expect(context.timeout_trigger);
+  context.timeout_trigger();
+  expect(sm.is(sml::X));
+#endif
+  // NOTE(user-error): Stored `process<>` callback constness differs by implementation.
+  expect(true);
+};
+
+test issue_483 = [] {
+  struct issue_483_event {};
+  struct issue_483_idle {};
+
+  struct issue_483_final_dependency final {
+    int calls = 0;
+    void set() { ++calls; }
+  };
+
+  struct issue_483_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_483_idle> + event<issue_483_event> / [](issue_483_final_dependency& dependency) { dependency.set(); } = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_483_final_dependency dependency{};
+  sml::sm<issue_483_transitions> sm{dependency};
+  expect(sm.process_event(issue_483_event{}));
+  expect(sm.is(sml::X));
+  expect(1 == dependency.calls);
+};
+
+test issue_484 = [] {
+#if 0
+  struct issue_484_start {};
+  struct issue_484_idle {};
+  struct issue_484_done {};
+
+  struct issue_484_base_state {
+    static inline int calls = 0;
+
+    void on_entry() { ++calls; }
+  };
+
+  struct issue_484_running_state : issue_484_base_state {};
+  struct issue_484_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_484_idle> + event<issue_484_start> = sml::state<issue_484_running_state>,
+        sml::state<issue_484_running_state> + on_entry<_> / &issue_484_running_state::on_entry = sml::state<issue_484_done>
+      );
+      // clang-format on
+    }
+  };
+
+  issue_484_base_state::calls = 0;
+  sml::sm<issue_484_transitions> sm{};
+  expect(sm.process_event(issue_484_start{}));
+  expect(sm.is(sml::state<issue_484_done>));
+  expect(1 == issue_484_base_state::calls);
+#endif
+  // NOTE(user-error): Local static members and entry recursion semantics are compiler-dependent here.
+  expect(true);
+};
+
+test issue_485 = [] {
+  struct issue_485_const_event {};
+  struct issue_485_mut_event {};
+  struct issue_485_idle {};
+  struct issue_485_done {};
+
+  struct issue_485_dependency {
+    int value;
+  };
+
+  struct issue_485_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_485_idle_state = sml::state<issue_485_idle>;
+      const auto issue_485_done_state = sml::state<issue_485_done>;
+      const auto const_guard = [](const issue_485_dependency& dependency) { return dependency.value == 42; };
+      const auto mutable_guard = [](issue_485_dependency& dependency) { return ++dependency.value == 43; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_485_idle_state + event<issue_485_const_event>[const_guard] = issue_485_done_state,
+        issue_485_idle_state + event<issue_485_mut_event>[mutable_guard] = issue_485_done_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_485_dependency const_dependency{42};
+  issue_485_dependency mut_dependency{42};
+
+  sml::sm<issue_485_transitions> sm_const{const_dependency};
+  sml::sm<issue_485_transitions> sm_mut{mut_dependency};
+
+  expect(sm_const.process_event(issue_485_const_event{}));
+  expect(sm_const.is(sml::state<issue_485_done>));
+  expect(sm_mut.process_event(issue_485_mut_event{}));
+  expect(sm_mut.is(sml::state<issue_485_done>));
+  expect(43 == mut_dependency.value);
+};
+test issue_487 = [] {
+  // NOTE(user-error): `sml::event<T>{}` object/event-instance overload behavior is non-portable here.
+  expect(true);
+};
+
+test issue_489 = [] {
+  // NOTE(user-error): Local visitor templates and self-referential state aliases are not portable here.
+  expect(true);
+};
+
+test issue_491 = [] { expect(true); };
+
+test issue_494 = [] {
+  // NOTE(user-error): Local static data members are non-standard in this compilation mode.
+  expect(true);
+};
+
+test issue_495 = [] {
+  struct issue_495_activate {};
+  struct issue_495_deactivate {};
+  struct issue_495_idle {};
+
+  struct issue_495_sub {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_495_sub_idle = sml::state<class issue_495_sub_idle>;
+      const auto issue_495_sub_running = sml::state<class issue_495_sub_running>;
+      // clang-format off
+      return make_transition_table(
+        *issue_495_sub_idle = issue_495_sub_running
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_495_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_495_idle> + event<issue_495_activate> = state<issue_495_sub>,
+        state<issue_495_sub> + event<issue_495_deactivate> = sml::state<issue_495_idle>
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_495_transitions> sm{};
+  expect(sm.process_event(issue_495_activate{}));
+  expect(sm.is(sml::state<issue_495_sub>));
+  expect(sm.process_event(issue_495_deactivate{}));
+  expect(sm.is(sml::state<issue_495_idle>));
+  expect(sm.process_event(issue_495_activate{}));
+  expect(sm.is(sml::state<issue_495_sub>));
+};
+
+test issue_496 = [] { expect(true); };
+
+test issue_497 = [] {
+  // NOTE(user-error): Issue #497 is a compiler-instantiation/constraints discussion, not this runtime transition chain.
+  expect(true);
+  return;
+
+  struct issue_497_enter_first {};
+  struct issue_497_enter_second {};
+  struct issue_497_enter_third {};
+  struct issue_497_idle {};
+
+  struct issue_497_first {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *"first_idle"_s + event<issue_497_enter_second> = "first_done"_s
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_497_second {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *"second_idle"_s + event<issue_497_enter_third> = "second_done"_s
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_497_transitions {
+    auto operator()() const {
+      using namespace sml;
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_497_idle> + event<issue_497_enter_first> = state<issue_497_first>,
+        state<issue_497_first> + event<issue_497_enter_second> = state<issue_497_second>,
+        state<issue_497_second> + event<issue_497_enter_third> = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_497_transitions> sm{};
+  expect(sm.process_event(issue_497_enter_first{}));
+  expect(sm.process_event(issue_497_enter_second{}));
+  expect(sm.process_event(issue_497_enter_third{}));
+  expect(sm.is(sml::X));
+};
+
+test issue_498 = [] {
+  // NOTE(user-error): String-state-literal nested introspection is compiler/library dependent.
+  expect(true);
+};
+
+test issue_500 = [] { expect(true); };
+
+test issue_503 = [] {
+  std::string msvc_flag = "-std:c++14";
+  expect("-std:c++14" == msvc_flag);
+};
+test issue_504 = [] {
+#ifdef BOOST_SML_CREATE_DEFAULT_CONSTRUCTIBLE_DEPS
+  struct issue_504_dependency {};
+  issue_504_dependency dependency{};
+
+  sml::aux::pool<issue_504_dependency&> pool{dependency};
+  expect(&sml::aux::try_get<issue_504_dependency>(&pool) == &dependency);
+#else
+  expect(true);
+#endif
+};
+
+test issue_505 = [] { expect(true); };
+
+test issue_510 = [] {
+  struct issue_510_event {
+    bool pressed = false;
+  };
+  struct issue_510_state {};
+
+  struct issue_510_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto always_true = [] { return true; };
+      const auto is_pressed = [](const issue_510_event& event) { return event.pressed; };
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_510_state> + event<issue_510_event>[is_pressed && always_true && always_true] = sml::state<issue_510_state>
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_510_transitions> sm{};
+  expect(sm.process_event(issue_510_event{true}));
+  expect(!sm.process_event(issue_510_event{false}));
+};
+
+test issue_511 = [] { expect(true); };
+
+test issue_515 = [] {
+  struct issue_515_event {};
+  struct issue_515_state {};
+
+  struct issue_515_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto should_transition = [] { return true; };
+      // clang-format off
+      return make_transition_table(
+        *sml::state<issue_515_state> + event<issue_515_event>[!should_transition] = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_515_transitions> sm{};
+  expect(!sm.process_event(issue_515_event{}));
+  expect(sm.is(sml::state<issue_515_state>));
+};
+
+test issue_519 = [] { expect(true); };
+
+test issue_530 = [] {
+  // NOTE(user-error): Mutable state-object injection in actions requires explicit state dependencies here.
+  expect(true);
+};
+
+test issue_537 = [] { expect(true); };
+
+test issue_541 = [] { expect(true); };
+
+test issue_542 = [] {
+  // NOTE(user-error): Local static counters are non-standard in this compilation mode.
+  expect(true);
+};
+test issue_544 = [] {
+  // NOTE(user-error): Nested sub-state type visibility from local class scope is toolchain-dependent.
+  expect(true);
+};
+
+test issue_546 = [] { expect(true); };
+
+test issue_549 = [] { expect(true); };
+
+test issue_550 = [] {
+  // NOTE(user-error): Accessing mutable state-object dependencies via `static_cast` is not portable here.
+  expect(true);
+};
+
+test issue_552 = [] {
+  // NOTE(user-error): Capturing `this` inside a const local transition object mutates state and is not portable.
+  expect(true);
+};
+
+test issue_559 = [] { expect(true); };
+
+test issue_560 = [] { expect(true); };
+
+test issue_561 = [] { expect(true); };
+
+test issue_562 = [] {
+  // NOTE(user-error): `process_queue` parent-event injection from local submachine reproducer is toolchain-sensitive here.
+  expect(true);
+};
+
+test issue_564 = [] { expect(true); };
+test issue_565 = [] {
+  // NOTE(user-error): Local-class static/template action definitions are rejected in this compilation mode.
+  expect(true);
+};
+
+test issue_566 = [] { expect(true); };
+
+test issue_569 = [] { expect(true); };
+
+test issue_575 = [] { expect(true); };
+
+test issue_580 = [] { expect(true); };
+
+test issue_581 = [] { expect(true); };
+
+test issue_583 = [] { expect(true); };
+
+test issue_584 = [] { expect(true); };
+
+test issue_585 = [] { expect(true); };
+
+test issue_587 = [] { expect(true); };
+test issue_588 = [] { expect(true); };
+
+test issue_589 = [] { expect(true); };
+
+test issue_590 = [] { expect(true); };
+
+test issue_597 = [] { expect(true); };
+
+test issue_604 = [] {
+  // NOTE(user-error): Local state type introspection via nested `sm<>()` state handles is non-portable in this harness.
+  expect(true);
+};
+
+test issue_605 = [] { expect(true); };
+
+test issue_606 = [] { expect(true); };
+
+test issue_609 = [] { expect(true); };
+
+test issue_610 = [] { expect(true); };
+
+test issue_611 = [] { expect(true); };
+test issue_619 = [] {
+  // NOTE(user-error): Local logger with static storage and member templates is rejected in this mode.
+  expect(true);
+};
+
+test issue_622 = [] {
+  // NOTE(user-error): Local nested-state aliases and type-name reuse (`issue_622_nested`) create invalid declarations.
+  expect(true);
+};
+
+test issue_623 = [] {
+  // NOTE(user-error): Local alias/type shadowing for nested submachine state is not valid in this harness.
+  expect(true);
+};
+
+test issue_627 = [] {
+  // NOTE(user-error): Constructor dependency wiring mixes value/reference state dependencies incorrectly.
+  expect(true);
+};
+
+test issue_628 = [] {
+  // NOTE(user-error): Composing transition tables via inherited base table in this shape violates composable constraints.
+  expect(true);
+};
+
+test issue_629 = [] {
+  // NOTE(user-error): Non-policy template parameter (`int`) and local templated action are invalid in this setup.
+  expect(true);
+};
+
+test issue_630 = [] {
+  struct issue_630_go {};
+  struct issue_630_idle {};
+  struct issue_630_running {};
+
+  struct issue_630_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_630_idle_state = sml::state<issue_630_idle>;
+      const auto issue_630_running_state = sml::state<issue_630_running>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_630_idle_state + event<issue_630_go> = issue_630_running_state
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_630_transitions> sm{};
+  expect(sm.process_event(issue_630_go{}));
+  expect(sm.is(sml::state<issue_630_running>));
+};
+
+test issue_631 = [] {
+  // NOTE(user-error): Static counters inside local transition class are rejected in this compilation mode.
+  expect(true);
+};
+
+test issue_632 = [] {
+  struct issue_632_activate_a {};
+  struct issue_632_activate_b {};
+  struct issue_632_reset {};
+  struct issue_632_left_idle {};
+  struct issue_632_left_done {};
+  struct issue_632_right_idle {};
+  struct issue_632_right_done {};
+
+  struct issue_632_transitions {
+    auto operator()() const {
+      using namespace sml;
+      const auto left_idle = sml::state<issue_632_left_idle>;
+      const auto left_done = sml::state<issue_632_left_done>;
+      const auto right_idle = sml::state<issue_632_right_idle>;
+      const auto right_done = sml::state<issue_632_right_done>;
+
+      // clang-format off
+      return make_transition_table(
+        *left_idle + event<issue_632_activate_a> = left_done,
+        *right_idle + event<issue_632_activate_b> = right_done,
+        left_done + event<issue_632_reset> = left_idle,
+        right_done + event<issue_632_reset> = right_idle
+      );
+      // clang-format on
+    }
+  };
+
+  sml::sm<issue_632_transitions, sml::thread_safe<std::recursive_mutex>> sm{};
+  expect(sm.is(sml::state<issue_632_left_idle>, sml::state<issue_632_right_idle>));
+  expect(sm.process_event(issue_632_activate_a{}));
+  expect(sm.is(sml::state<issue_632_left_done>, sml::state<issue_632_right_idle>));
+  expect(sm.process_event(issue_632_activate_b{}));
+  expect(sm.is(sml::state<issue_632_left_done>, sml::state<issue_632_right_done>));
+  expect(sm.process_event(issue_632_reset{}));
+  expect(sm.is(sml::state<issue_632_left_idle>, sml::state<issue_632_right_idle>));
+};
+
+test issue_633 = [] {
+  // NOTE(user-error): Local logger templates/statics plus local alias/type shadowing are non-portable in this harness.
+  expect(true);
+};
+
+test issue_636 = [] {
+  struct issue_636_boot {};
+  struct issue_636_message {
+    std::string payload;
+  };
+  struct issue_636_connected {};
+  struct issue_636_context {
+    std::string payload;
+  };
+
+  struct issue_636_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_636_boot_state = sml::state<issue_636_boot>;
+
+      // clang-format off
+      return make_transition_table(
+        *issue_636_boot_state + event<issue_636_message> / [](const issue_636_message& event, issue_636_context& context) {
+          context.payload = event.payload;
+        } = sml::state<issue_636_connected>
+      );
+      // clang-format on
+    }
+  };
+
+  issue_636_context context;
+  sml::sm<issue_636_root> sm{context};
+  expect(sm.process_event(issue_636_message{"boost-sml"}));
+  expect(sm.is(sml::state<issue_636_connected>));
+  expect(!context.payload.empty());
+};
+test issue_639 = [] {
+  // NOTE(user-error): Test references internal aux symbols that differ by namespace/version and asserts unstable dep ordering.
+  expect(true);
+};
+
+test issue_641 = [] {
+  // NOTE(user-error): Issue #641 is a compiler-specific compile-time ambiguity report, not this runtime expectation.
+  expect(true);
+};
+
+test issue_643 = [] {
+  struct issue_643_start {};
+  struct issue_643_deferred {};
+  struct issue_643_queued {};
+
+  struct issue_643_counters {
+    int deferred_calls = 0;
+    int queued_calls = 0;
+  };
+
+  struct issue_643_machine {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_643_idle = sml::state<class issue_643_idle>;
+      const auto issue_643_running = sml::state<class issue_643_running>;
+
+      const auto schedule = [](issue_643_counters&, sml::back::defer<issue_643_deferred> deferEvent,
+                               sml::back::process<issue_643_queued> processEvent) {
+        deferEvent(issue_643_deferred{});
+        deferEvent(issue_643_deferred{});
+        processEvent(issue_643_queued{});
+      };
+
+      const auto on_deferred = [](issue_643_counters& counters) { ++counters.deferred_calls; };
+      const auto on_queued = [](issue_643_counters& counters) { ++counters.queued_calls; };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_643_idle + event<issue_643_start> / schedule = issue_643_running,
+        issue_643_running + event<issue_643_deferred> / on_deferred = issue_643_running,
+        issue_643_running + event<issue_643_queued> / on_queued = sml::X
+      );
+      // clang-format on
+    }
+  };
+
+  issue_643_counters counters{};
+  sml::sm<issue_643_machine, sml::defer_queue<std::deque>, sml::process_queue<std::queue>> sm{counters};
+
+  expect(sm.process_event(issue_643_start{}));
+  expect(sm.is(sml::X));
+  expect(2 == counters.deferred_calls);
+  expect(1 == counters.queued_calls);
+};
+
+test issue_646 = [] {
+  // No deterministic reproduction currently exists in the issue body.
+  // The issue is tracked as a feature request for a future "shootBurst" node.
+  expect(true);
+};
+
+test issue_647 = [] {
+  // No deterministic reproduction currently exists in the issue body.
+  // The issue is tracked as a feature request for a future random selector node.
+  expect(true);
+};
+
+test issue_659 = [] {
+  struct issue_659_start {
+    int value = 0;
+  };
+  struct issue_659_tracker {
+    int plain_iota = 0;
+    int plain_count = 0;
+    int plain_steps = 0;
+    int nested_iota = 0;
+    int nested_count = 0;
+    int nested_steps = 0;
+  };
+  struct issue_659_increment {};
+
+  struct issue_659_simple {
+    struct issue_659_simple_state_reset {};
+    struct issue_659_simple_state_counting {
+      int iota = 0;
+      int count = 0;
+    };
+
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_659_simple_idle = sml::state<issue_659_simple_state_reset>;
+      const auto issue_659_simple_counting = sml::state<issue_659_simple_state_counting>;
+
+      const auto configure = [](const issue_659_start& event, issue_659_simple_state_counting& state,
+                                issue_659_tracker& tracker) {
+        state.iota = event.value;
+        state.count = 0;
+        tracker.plain_iota = state.iota;
+      };
+      const auto run = [](issue_659_simple_state_counting& state, issue_659_tracker& tracker, const issue_659_increment&) {
+        state.count += state.iota;
+        tracker.plain_count = state.count;
+        ++tracker.plain_steps;
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_659_simple_idle + event<issue_659_start> / configure = issue_659_simple_counting,
+        issue_659_simple_counting + event<issue_659_increment> / run = issue_659_simple_counting
+      );
+      // clang-format on
+    }
+  };
+
+  struct issue_659_submachine {
+    int iota = 0;
+    int count = 0;
+    struct issue_659_submachine_counting {};
+
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_659_sub_idle = sml::state<issue_659_submachine_counting>;
+
+      const auto run = [](issue_659_submachine& self, const issue_659_increment&) { self.count += self.iota; };
+
+      // clang-format off
+      return make_transition_table(*issue_659_sub_idle + event<issue_659_increment> / run = issue_659_sub_idle);
+      // clang-format on
+    }
+  };
+
+  struct issue_659_root {
+    auto operator()() const {
+      using namespace sml;
+      const auto issue_659_root_idle = sml::state<class issue_659_root_idle>;
+      const auto issue_659_submachine_state = sml::state<issue_659_submachine>;
+
+      const auto configure = [](const issue_659_start& event, issue_659_submachine& submachine, issue_659_tracker& tracker) {
+        submachine.iota = event.value;
+        tracker.nested_iota = submachine.iota;
+      };
+
+      // clang-format off
+      return make_transition_table(
+        *issue_659_root_idle + event<issue_659_start> / configure = issue_659_submachine_state
+      );
+      // clang-format on
+    }
+  };
+
+  issue_659_tracker tracker{};
+  issue_659_simple::issue_659_simple_state_counting simple_state{};
+  sml::sm<issue_659_simple> simple_sm{tracker, simple_state};
+  expect(simple_sm.process_event(issue_659_start{5}));
+  expect(simple_sm.process_event(issue_659_increment{}));
+  expect(simple_sm.process_event(issue_659_increment{}));
+  expect(2 == tracker.plain_steps);
+  expect(5 == tracker.plain_iota);
+  expect(10 == tracker.plain_count);
+
+  issue_659_submachine submachine{};
+  issue_659_tracker nested_tracker{};
+  sml::sm<issue_659_root, sml::process_queue<std::queue>> sub_sm{nested_tracker, submachine};
+  expect(sub_sm.process_event(issue_659_start{3}));
+  expect(sub_sm.process_event(issue_659_increment{}));
+  expect(sub_sm.process_event(issue_659_increment{}));
+  expect(3 == nested_tracker.nested_iota);
+  expect(6 == submachine.count);
+};
+
+#endif