From 61c4b17cb2402b94a3a01a6ec7ce44c5151b9a16 Mon Sep 17 00:00:00 2001
From: Christian Granzin <christian.granzin@gmail.com>
Date: Thu, 18 Jun 2026 17:03:33 +0200
Subject: [PATCH 1/2] feat(backmp11): terminate state, interrupt state, machine
 state

---
 .../ROOT/attachments/backmp11/BackAdapter.cpp |   6 +
 .../backmp11/InterruptibleStateMachine.cpp    | 134 ++++++++++++
 .../backmp11/serializer/BoostJson.cpp         |   6 +-
 .../backmp11/serializer/NlohmannJson.cpp      |  12 +-
 doc/modules/ROOT/pages/backmp11-back-end.adoc |  67 +++---
 .../pages/backmp11-back-end/examples.adoc     |  12 +-
 doc/modules/ROOT/pages/version-history.adoc   |   1 +
 include/boost/msm/backmp11/common_types.hpp   |   6 +-
 .../backmp11/detail/state_machine_base.hpp    |  12 +-
 .../msm/backmp11/detail/transition_table.hpp  |   2 +-
 .../msm/backmp11/serialization/boost_json.hpp |  17 +-
 .../backmp11/serialization/nlohmann_json.hpp  |  12 --
 include/boost/msm/backmp11/state_machine.hpp  | 192 +++++++++---------
 test/Backmp11.hpp                             |  72 +++++++
 test/Backmp11MachineState.cpp                 | 163 +++++++++++++++
 test/Backmp11Serialization.cpp                |  12 +-
 test/CMakeLists.txt                           |   1 +
 test/Jamfile.v2                               |   1 +
 test/Utils.hpp                                | 116 +++++++++++
 19 files changed, 657 insertions(+), 187 deletions(-)
 create mode 100644 doc/modules/ROOT/attachments/backmp11/InterruptibleStateMachine.cpp
 create mode 100644 test/Backmp11MachineState.cpp

diff --git a/doc/modules/ROOT/attachments/backmp11/BackAdapter.cpp b/doc/modules/ROOT/attachments/backmp11/BackAdapter.cpp
index d006d63a..5a785167 100644
--- a/doc/modules/ROOT/attachments/backmp11/BackAdapter.cpp
+++ b/doc/modules/ROOT/attachments/backmp11/BackAdapter.cpp
@@ -171,6 +171,12 @@ class back_adapter : public boost::msm::backmp11::state_machine<
     template <typename Event>
     boost::msm::back::HandledEnum process_event(const Event& event)
     {
+        if (this->template is_flag_active<boost::msm::InterruptedFlag>() &&
+            !this->is_end_interrupt_event(event))
+        {
+            return boost::msm::back::HANDLED_TRUE;
+        }
+
         if (this->get_machine_state() ==
             boost::msm::backmp11::machine_state::processing)
         {
diff --git a/doc/modules/ROOT/attachments/backmp11/InterruptibleStateMachine.cpp b/doc/modules/ROOT/attachments/backmp11/InterruptibleStateMachine.cpp
new file mode 100644
index 00000000..96aff353
--- /dev/null
+++ b/doc/modules/ROOT/attachments/backmp11/InterruptibleStateMachine.cpp
@@ -0,0 +1,134 @@
+// Copyright 2026 Christian Granzin
+// Copyright 2010 Christophe Henry
+// henry UNDERSCORE christophe AT hotmail DOT com
+// This is an extended version of the state machine available in the boost::mpl library
+// Distributed under the same license as the original.
+// Copyright for the original version:
+// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
+// under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+
+#include <boost/msm/backmp11/state_machine.hpp>
+#include <boost/msm/front/functor_row.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace back = boost::msm::backmp11;
+namespace front = boost::msm::front;
+using front::Row;
+using front::Internal;
+namespace mp11 = boost::mp11;
+
+namespace
+{
+
+// Events.
+struct InterruptEvent {};
+struct SmInternalEvent {};
+
+// Actions.
+struct Interrupt
+{
+    template <typename Fsm>
+    void operator()(Fsm& fsm)
+    {
+        fsm.interrupt();
+    }
+};
+
+struct PrintMessage
+{
+    template <typename Fsm>
+    void operator()(const SmInternalEvent&, Fsm&)
+    {
+        if (talk)
+        {
+            std::cout << "Processed SmInternalEvent" << std::endl;
+        }
+    }
+
+    [[maybe_unused]] static inline bool talk{true};
+};
+
+// States.
+struct MyState : front::state<> {};
+
+struct MyOtherState : front::state<> {};
+
+// State machine.
+struct InterruptibleStateMachine_
+    : front::state_machine_def<InterruptibleStateMachine_>
+{
+    using initial_state = MyState;
+    using transition_table = mp11::mp_list<
+        Row<MyState, InterruptEvent, front::none, Interrupt>
+    >;
+    using internal_transition_table = mp11::mp_list<
+        Internal<SmInternalEvent, PrintMessage>
+    >;
+};
+
+template <typename Config = back::state_machine_config>
+class InterruptibleStateMachine
+    : public back::state_machine<InterruptibleStateMachine_, Config,
+                                 InterruptibleStateMachine<Config>>
+{
+    using Base = back::state_machine<InterruptibleStateMachine_, Config,
+                                     InterruptibleStateMachine<Config>>;
+
+  public:
+    using Base::Base;
+
+    void interrupt()
+    {
+        m_interrupted = true;
+    }
+
+    void resume()
+    {
+        m_interrupted = false;
+        this->process_event_pool();
+    }
+
+    template <typename Event>
+    back::process_result process_event(const Event& event)
+    {
+        if (m_interrupted)
+        {
+            // Enqueue all events for later processing
+            // as long as the state machine is interrupted.
+            this->enqueue_event(event);
+            return back::process_result::deferred;
+        }
+        else
+        {
+            return Base::process_event(event);
+        }
+    }
+
+  private:
+    bool m_interrupted{};
+};
+
+
+[[maybe_unused]] void interruptible_state_machine_example()
+{
+    InterruptibleStateMachine<> state_machine;
+    
+    state_machine.start();
+
+    // Interrupt the state machine.
+    state_machine.process_event(InterruptEvent{});
+
+    // The event is not yet processed.
+    state_machine.process_event(SmInternalEvent{});
+
+    // Resuming the state machine processes the event and prints:
+    // "Processed SmInternalEvent"
+    state_machine.resume();
+}
+
+} // namespace
+
diff --git a/doc/modules/ROOT/attachments/backmp11/serializer/BoostJson.cpp b/doc/modules/ROOT/attachments/backmp11/serializer/BoostJson.cpp
index c5207fd9..10124a5a 100644
--- a/doc/modules/ROOT/attachments/backmp11/serializer/BoostJson.cpp
+++ b/doc/modules/ROOT/attachments/backmp11/serializer/BoostJson.cpp
@@ -50,14 +50,14 @@ std::string to_boost_json_string(const DimSwitch& dim_switch)
     // The initial state is Off (state id 0).
     dim_switch.start();
     // Prints:
-    // {"front_end":{"brightness":0},"states":{"1":{"times_pressed":0}},"active_state_ids":[0],"stopped":false}
+    // {"front_end":{"brightness":0},"states":{"1":{"times_pressed":0}},"active_state_ids":[0],"machine_state":1}
     std::cout << to_boost_json_string(dim_switch) << std::endl;
 
     // Turn On (state id 1) and set brightness to 75.
     dim_switch.process_event(TurnOn{});
     dim_switch.process_event(Dim{75});
     // Prints:
-    // {"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"stopped":false}
+    // {"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"machine_state":1}
     std::cout << to_boost_json_string(dim_switch) << std::endl;
 
     // Deserialize the json into a new state machine.
@@ -65,7 +65,7 @@ std::string to_boost_json_string(const DimSwitch& dim_switch)
     const auto dim_switch_2 = boost::json::value_to<DimSwitch>(json);
 
     // Prints:
-    // {"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"stopped":false}
+    // {"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"machine_state":1}
     std::cout << to_boost_json_string(dim_switch_2) << std::endl;
 }
 
diff --git a/doc/modules/ROOT/attachments/backmp11/serializer/NlohmannJson.cpp b/doc/modules/ROOT/attachments/backmp11/serializer/NlohmannJson.cpp
index e0ef722b..5061f6ce 100644
--- a/doc/modules/ROOT/attachments/backmp11/serializer/NlohmannJson.cpp
+++ b/doc/modules/ROOT/attachments/backmp11/serializer/NlohmannJson.cpp
@@ -59,12 +59,12 @@ std::string to_nlohmann_json_string(const DimSwitch& dim_switch)
     //     "front_end": {
     //         "brightness": 0
     //     },
+    //     "machine_state": 1,
     //     "states": {
     //         "1": {
     //             "times_pressed": 0
     //         }
-    //     },
-    //     "stopped": false
+    //     }
     // }
     std::cout << to_nlohmann_json_string(dim_switch) << std::endl;
 
@@ -79,12 +79,12 @@ std::string to_nlohmann_json_string(const DimSwitch& dim_switch)
     //     "front_end": {
     //         "brightness": 75
     //     },
+    //     "machine_state": 1,
     //     "states": {
     //         "1": {
     //             "times_pressed": 1
     //         }
-    //     },
-    //     "stopped": false
+    //     }
     // }
     std::cout << to_nlohmann_json_string(dim_switch) << std::endl;
     // Deserialize the json into a new state machine.
@@ -100,12 +100,12 @@ std::string to_nlohmann_json_string(const DimSwitch& dim_switch)
     //     "front_end": {
     //         "brightness": 75
     //     },
+    //     "machine_state": 1,
     //     "states": {
     //         "1": {
     //             "times_pressed": 1
     //         }
-    //     },
-    //     "stopped": false
+    //     }
     // }
     std::cout << to_nlohmann_json_string(dim_switch_2) << std::endl;
 }
diff --git a/doc/modules/ROOT/pages/backmp11-back-end.adoc b/doc/modules/ROOT/pages/backmp11-back-end.adoc
index 018bf005..d452e7f6 100644
--- a/doc/modules/ROOT/pages/backmp11-back-end.adoc
+++ b/doc/modules/ROOT/pages/backmp11-back-end.adoc
@@ -15,8 +15,8 @@ It offers a significant improvement in runtime and memory usage, as can be seen
 | back                        | 10                 | 844              | 73               | 0.7
 | back_favor_compile_time     | 12                 | 821              | 241              | 1.0
 | back11                      | 26                 | 2675             | 92               | 0.7
-| backmp11                    | 2                  | 236              | 18               | 0.2
-| backmp11_favor_compile_time | 2                  | 226              | 44               | 2.2
+| backmp11                    | 2                  | 236              | 19               | 0.2
+| backmp11_favor_compile_time | 2                  | 225              | 44               | 2.2
 | sml                         | 4                  | 254              | 64               | 0.1
 |=======================================================================================================
 
@@ -28,9 +28,9 @@ It offers a significant improvement in runtime and memory usage, as can be seen
 |                             | Compile time / sec | Compile RAM / MB | Binary size / kB | Runtime / sec
 | back                        | 32                 | 2160             | 252              | 3.7
 | back_favor_compile_time     | 37                 | 1747             | 974              | 263
-| backmp11                    | 5                  | 362              | 55               | 0.9
-| backmp11_favor_compile_time | 3                  | 266              | 96               | 7.5
-| sml                         | 13                 | 612              | 460              | 2.8
+| backmp11                    | 5                  | 360              | 57               | 0.9
+| backmp11_favor_compile_time | 3                  | 265              | 96               | 7.6
+| sml                         | 13                 | 612              | 431              | 2.8
 |=======================================================================================================
 
 
@@ -173,7 +173,7 @@ When a transition defined in SM1 causes SM2 and SM3 to exit:
 
 === Event pool
 
-The setting `event_pool` configures the container and inline storage the back-end uses to hold work that cannot be processed immediately: enqueued events, deferred events, and completion transitions.
+The setting `event_pool` configures the container and inline storage the back-end uses to hold work that cannot be processed immediately: enqueued events, deferred events, completion transitions, and state machine termination.
 
 ```cpp
 template <template <typename> typename Container,
@@ -200,7 +200,7 @@ By replacing `std::deque` with a fixed-capacity container and setting `InlineCap
 See the xref:backmp11-back-end/examples.adoc#_heapless_state_machine[heapless state machine example] for a demo using `boost::container::static_vector`.
 ====
 
-Use `no_event_pool` to disable the event pool if the state machine does not require event enqueueing, deferral, and completion transitions:
+Use `no_event_pool` to deactivate the event pool if you don't need it. This setting disables all related functionality, improves runtime performance, and reduces the state machine's memory footprint.
 
 ```cpp
 struct MyConfig : state_machine_config
@@ -298,11 +298,13 @@ struct MyStateMachine_ : public msm::front::state_machine_def<MyStateMachine_>
 
 == Start and stop
 
-A newly constructed state machine is inactive and does not process events as long as it is not yet started. The xref:reference:boost/msm/backmp11/state_machine/start-04.adoc[`void state_machine::start()`] method activates the state machine by first calling the state machine front-end's entry action and then the initial state's. By default, the event passed to the entry actions is an empty struct xref:reference:boost/msm/backmp11/starting.adoc[`starting`]. You can pass a custom event with the overload xref:reference:boost/msm/backmp11/state_machine/start-0a.adoc[`void state_machine::start(const auto& initial_event)`].
+A newly constructed state machine does not accept events as long as it is not yet started. Its own state is represented in the xref:reference:boost/msm/backmp11/machine_state.adoc[`machine_state`] enum, which you can query with xref:reference:boost/msm/backmp11/state_machine/get_machine_state.adoc[`machine_state state_machine::get_machine_state()`].
 
-The xref:reference:boost/msm/backmp11/state_machine/stop-03.adoc[`void state_machine::stop()`] method deactivates the state machine by first calling the active state's exit action and then the state machine front-end's. The default event in this case is an empty struct xref:reference:boost/msm/backmp11/stopping.adoc[`stopping`], and a similar overload xref:reference:boost/msm/backmp11/state_machine/stop-05.adoc[`void state_machine::stop(const auto& final_event)`] exists to customize it.
+The xref:reference:boost/msm/backmp11/state_machine/start-04.adoc[`void state_machine::start()`] method activates the state machine with a xref:reference:boost/msm/backmp11/starting.adoc[`starting`] event by first calling the state machine front-end's entry action and then the initial state's. You can pass a custom start event with the overload xref:reference:boost/msm/backmp11/state_machine/start-0a.adoc[`void state_machine::start(const auto& initial_event)`].
 
-Calling `start(...)` on an active or `stop(...)` on an inactive state machine has no effect.
+The xref:reference:boost/msm/backmp11/state_machine/stop-03.adoc[`void state_machine::stop()`] method deactivates the state machine with a xref:reference:boost/msm/backmp11/stopping.adoc[`stopping`] event by first calling the active state's exit action and then the state machine front-end's. A similar overload xref:reference:boost/msm/backmp11/state_machine/stop-05.adoc[`void state_machine::stop(const auto& final_event)`] exists to pass a custom stop event.
+
+Calling `start(...)` on an active or `stop(...)` on an inactive state machine has no effect. Note that a state machine must be ready to process events in order to stop it.
 
 
 == Handling events
@@ -452,20 +454,17 @@ Serializing a state machine to JSON provides a neat way to inspect it in a human
 
 The back-end uses the following run-to-completion algorithm for processing events:
 
-* Return if the state machine is not ready to process the event. It is ready if:
-** it is started and
-** it is not already processing an event and
-** either no terminate state is active, or an interrupt state is active and the event ends the interrupt state
+* Return if the state machine is not ready to process the event. It is ready if it is started and not already processing
 * If an active state defers the event, push it to the end of the event pool and return
 * Dispatch the event to the transition table of every region, in the order defined by the front-end's `initial_state`
-* For each transition matching the active state and the event (in _reverse_ order of the front-end's transition table):
+* _For each transition_ matching the active state and the event (in _reverse_ order of the front-end's transition table):
 ** Execute the transition if there is no guard or it returns true, otherwise skip it
 ** If the transition has a target state, call the source state's exit action and then switch the active state to the target state
 ** If the transition has a transition action, call it
 ** If the transition has a target state, call the target state's entry action
 ** If a completion transition exists for the target state, push its execution to the beginning of the event pool
 ** Consider the event processed and finish the transition execution loop
-* If the event is not yet processed and the state machine has an internal transition table, dispatch it to the internal transition table as well. For each transition matching the event (in _reverse_ order of the front-end's internal transition table):
+* If the event is not yet processed and the state machine has an internal transition table, dispatch it to the internal transition table as well. _For each internal transition_ matching the event (in _reverse_ order of the front-end's internal transition table):
 ** Execute the transition if there is no guard or it returns true, otherwise skip it
 ** If the transition has a transition action, call it
 ** Consider the event processed and finish the transition execution loop
@@ -491,7 +490,7 @@ The following sections provide further details about the differences between `ba
 
 === Public API of `state_machine`
 
-The following adapter pseudo-code illustrates the differences from the `back::state_machine` API (see xref:backmp11-back-end/examples.adoc#_back_adapter[`full code example`]).
+The following adapter pseudo-code illustrates the main differences from the `back::state_machine` API (see xref:backmp11-back-end/examples.adoc#_back_adapter[`full code example`]).
 
 ```cpp
 class back_adapter
@@ -499,31 +498,26 @@ class back_adapter
     template <typename Event>
     back::HandledEnum process_event(const Event& event)
     {
-        if (this->get_machine_state() == detail::machine_state::processing)
+        if (get_machine_state() == machine_state::processing)
         {
-            this->enqueue_event(event);
+            enqueue_event(event);
             return back::HANDLED_DEFERRED;
         }
         else
         {
             try
             {
-                return Base::process_event(event);
+                return static_cast<back::HandledEnum>(
+                    Base::process_event(event));
             }
             catch (std::exception& e)
             {
-                this->exception_caught(event, *this, e);
+                exception_caught(event, *this, e);
                 return back::HANDLED_FALSE;
             }
         }
     }
 
-    // The new API returns a const std::array<...>&.
-    const uint16_t* current_state() const
-    {
-        return &this->get_active_state_ids()[0];
-    }
-
     auto& get_message_queue()
     {
         return this->get_event_pool().events;
@@ -553,18 +547,6 @@ class back_adapter
     {
         this->get_event_pool().events.clear();
     }
-
-    // No adapter.
-    // Superseded by the visitor API.
-    // void visit_current_states(...) {...}
-
-    // No adapter.
-    // States can be set with `get_state<...>() = ...` or the visitor API.
-    // void set_states(...) {...}
-
-    // No adapter.
-    // Could be implemented with the visitor API.
-    // auto get_state_by_id(int id) {...}
 };
 ```
 
@@ -579,6 +561,13 @@ Futhermore, the back-end forwards Kleene events without converting them to `std:
 
 === Removed features
 
+==== Interrupt states
+
+Not supported, because the interrupt state evaluation requires a visitor to determine whether an interrupt state is active. This significantly increases the state machine's compilation time and runtime as soon as an interrupt state is defined. If needed, the interrupt state feature can be resembled with a state machine extension (see xref:backmp11-back-end/examples.adoc#_back_adapter[`back` adapter example]).
+
+In `backmp11`, you can extend the state machine API to implement your own interrupt mechanism and tailor it to your needs. See the xref:backmp11-back-end/examples.adoc#_interruptible_state_machine[`interruptible state machine example`], which allows interruptions from any state and enqueues events for later processing instead of discarding them.
+
+
 ==== Initialization of states in the constructor and the `set_states(...)` method
 
 There were some caveats with one constructor that was used for different use cases: On the one hand, some arguments were immediately forwarded to the front-end's constructor, on the other hand, the stream operator was used to identify other arguments in the constructor as states, to copy them into the state machine. Besides the syntax of the latter being rather unusual, when doing both at once, the syntax becomes too difficult to understand; even more so if states within hierarchical submachines are initialized in this fashion.
diff --git a/doc/modules/ROOT/pages/backmp11-back-end/examples.adoc b/doc/modules/ROOT/pages/backmp11-back-end/examples.adoc
index 3efddafb..83fd2d20 100644
--- a/doc/modules/ROOT/pages/backmp11-back-end/examples.adoc
+++ b/doc/modules/ROOT/pages/backmp11-back-end/examples.adoc
@@ -13,6 +13,14 @@ This example demonstrates a state machine configured for heapless execution.
 It uses `boost::container::static_vector` as the event pool container — a fixed-capacity replacement for the default `std::deque` container. Note that this container type does not support completion transitions; use a heapless deque (e.g. `etl::deque`) if those are required.
 
 
+== xref:attachment$backmp11/InterruptibleStateMachine.cpp[Interruptible state machine]
+
+This example demonstrates a state machine extended with an interrupt mechanism.
+
+The state machine provides a public API to pause and resume its execution. This way it can be interrupted externally as well as internally through an event.
+It can immediately continue from where it was interrupted, since the interruption does not require a state change.
+
+
 == xref:attachment$backmp11/Logger.cpp[Logger]
 
 This example contains an observer implementation for logging state machine activities.
@@ -50,12 +58,12 @@ A serialization to JSON is particularly useful for inspecting a state machine's
     "front_end": {
         "brightness": 75
     },
+    "machine_state": 1, // idle
     "states": {
         "1": {
             "times_pressed": 1
         }
-    },
-    "stopped": false
+    }
 }
 ```
 
diff --git a/doc/modules/ROOT/pages/version-history.adoc b/doc/modules/ROOT/pages/version-history.adoc
index eb2a703d..ee1ac42a 100644
--- a/doc/modules/ROOT/pages/version-history.adoc
+++ b/doc/modules/ROOT/pages/version-history.adoc
@@ -9,6 +9,7 @@
 ** Forward Kleene events to actions and guards without conversion (https://github.com/boostorg/msm/issues/229[#229])
 ** Ensure basic exception guarantee and propagate exceptions to the caller (https://github.com/boostorg/msm/issues/221[#221])
 ** Provide a reflection API and serialization support for Boost.Serialization, Boost.JSON and nlohmann/json (https://github.com/boostorg/msm/issues/197[#197])
+** Rework terminate and interrupt state handling and provide a `machine_state` enum (https://github.com/boostorg/msm/issues/244[#244])
 ** Configurable event pool and inline storage (https://github.com/boostorg/msm/issues/239[#239])
 ** API reference and examples are now available
 * Bug fixes (`backmp11`):
diff --git a/include/boost/msm/backmp11/common_types.hpp b/include/boost/msm/backmp11/common_types.hpp
index 06350f56..7c9b9ef5 100644
--- a/include/boost/msm/backmp11/common_types.hpp
+++ b/include/boost/msm/backmp11/common_types.hpp
@@ -21,12 +21,14 @@ namespace boost::msm::backmp11
 /// Describes the state of the state machine.
 enum class machine_state : uint8_t
 {
-    /// Stopped / not started.
+    /// Stopped, or not yet started.
     stopped = 0,
     /// Ready to process an event.
     idle,
     /// Processing an event.
-    processing
+    processing,
+    /// The machine is terminated and can no longer process events.
+    terminated,
 };
 
 /// Return type of @ref state_machine::process_event calls.
diff --git a/include/boost/msm/backmp11/detail/state_machine_base.hpp b/include/boost/msm/backmp11/detail/state_machine_base.hpp
index ae25b909..56eeb0c6 100644
--- a/include/boost/msm/backmp11/detail/state_machine_base.hpp
+++ b/include/boost/msm/backmp11/detail/state_machine_base.hpp
@@ -197,6 +197,13 @@ class state_machine_base
     using context_t = typename Config::context;
     using observer_t = typename Config::observer;
 
+    /// Gets the current state of the state machine.
+    /// See @ref machine_state.
+    machine_state get_machine_state() const
+    {
+        return m_machine_state;
+    }
+
     /// Gets the context of the state machine.
     /// See @ref state_machine_config::context.
     template <bool C = !std::is_same_v<context_t, no_context>,
@@ -309,11 +316,6 @@ class state_machine_base
     {
     }
 
-    machine_state get_machine_state() const
-    {
-        return m_machine_state;
-    }
-
   private:
     template <typename, nesting_role>
     friend class state_machine_base;
diff --git a/include/boost/msm/backmp11/detail/transition_table.hpp b/include/boost/msm/backmp11/detail/transition_table.hpp
index e513ad04..5b323541 100644
--- a/include/boost/msm/backmp11/detail/transition_table.hpp
+++ b/include/boost/msm/backmp11/detail/transition_table.hpp
@@ -337,7 +337,7 @@ struct transition_table_impl
             }
 
             // Give a chance to handle completion transitions.
-            sm.template on_state_entry_completed<next_state_type>(region_id);
+            sm.on_state_entry_completed(target, region_id);
 
             return res;
         }
diff --git a/include/boost/msm/backmp11/serialization/boost_json.hpp b/include/boost/msm/backmp11/serialization/boost_json.hpp
index 3f1b4a26..378741e2 100644
--- a/include/boost/msm/backmp11/serialization/boost_json.hpp
+++ b/include/boost/msm/backmp11/serialization/boost_json.hpp
@@ -50,11 +50,6 @@ class boost_json_serializer
         m_json.pop();
     }
 
-    void visit_member(const char* /*key*/, const machine_state& state)
-    {
-        top()["stopped"] = (state == machine_state::stopped);
-    }
-
     template <typename Member>
     void visit_member(const char* key, Member&& member)
     {
@@ -139,13 +134,6 @@ class boost_json_deserializer
         m_json.pop();
     }
 
-    void visit_member(const char* /*key*/, machine_state& state)
-    {
-        state = top().at("stopped").as_bool()
-            ? machine_state::stopped
-            : machine_state::idle;
-    }
-
     template <typename Member>
     void visit_member(const char* key, Member&& member)
     {
@@ -197,13 +185,14 @@ namespace boost::msm::backmp11
 inline void tag_invoke(const boost::json::value_from_tag&,
                        boost::json::value& json, const machine_state& state)
 {
-    json = (state == machine_state::stopped);
+    json = static_cast<std::underlying_type_t<machine_state>>(state);
 }
 
 inline machine_state tag_invoke(const boost::json::value_to_tag<machine_state>&,
                                 const boost::json::value& json)
 {
-    return json.as_bool() ? machine_state::stopped : machine_state::idle;
+    return static_cast<machine_state>(
+        json.to_number<std::underlying_type_t<machine_state>>());
 }
 
 template <typename StateMachine,
diff --git a/include/boost/msm/backmp11/serialization/nlohmann_json.hpp b/include/boost/msm/backmp11/serialization/nlohmann_json.hpp
index 208d3359..9651e554 100644
--- a/include/boost/msm/backmp11/serialization/nlohmann_json.hpp
+++ b/include/boost/msm/backmp11/serialization/nlohmann_json.hpp
@@ -47,11 +47,6 @@ class nlohmann_json_serializer
         m_json.pop();
     }
 
-    void visit_member(const char* /*key*/, const machine_state& state)
-    {
-        top()["stopped"] = (state == machine_state::stopped);
-    }
-
     template <typename Member>
     void visit_member(const char* key, Member&& member)
     {
@@ -111,13 +106,6 @@ class nlohmann_json_deserializer
         m_json.pop();
     }
 
-    void visit_member(const char* /*key*/, machine_state& state)
-    {
-        state = top().at("stopped").get<bool>()
-            ? machine_state::stopped
-            : machine_state::idle;
-    }
-
     template <typename Member>
     void visit_member(const char* key, Member&& member)
     {
diff --git a/include/boost/msm/backmp11/state_machine.hpp b/include/boost/msm/backmp11/state_machine.hpp
index bb3ba763..6bfe2357 100644
--- a/include/boost/msm/backmp11/state_machine.hpp
+++ b/include/boost/msm/backmp11/state_machine.hpp
@@ -334,7 +334,7 @@ class state_machine
     template <class Event>
     void stop(Event const& final_event)
     {
-        if (this->m_machine_state != machine_state::stopped)
+        if (this->m_machine_state == machine_state::idle)
         {
             on_exit(final_event, get_fsm_argument());
         }
@@ -550,24 +550,6 @@ class state_machine
             return process_result::discarded;
         }
 
-        // If the state machine has terminate or interrupt flags, check them.
-        if constexpr (mp11::mp_any_of<state_set, detail::is_state_blocking>::value)
-        {
-            // If the state machine is terminated, discard the event.
-            if (is_flag_active<TerminateFlag>())
-            {
-                return process_result::consumed;
-            }
-
-            // If the state machine is interrupted, discard the event
-            // unless it is the end interrupt event.
-            if (is_flag_active<InterruptedFlag>() &&
-                !is_end_interrupt_event(event))
-            {
-                return process_result::consumed;
-            }
-        }
-
         if constexpr (state_machine_base::has_event_pool)
         {
             if (info != detail::process_info::event_pool)
@@ -644,82 +626,6 @@ class state_machine
         return result;
     }
 
-    // MSCV Bug:
-    // Compile error if this class is named completion_event.
-    template <typename State>
-    class completion_event_occurrence : public detail::event_occurrence
-    {
-        // Merge each list of transitions into a chain if needed.
-        template <typename Transitions>
-        struct merge_transitions_impl;
-        template <typename Transition>
-        struct merge_transitions_impl<mp11::mp_list<Transition>>
-        {
-            using type = Transition;
-        };
-        template <typename... Transitions>
-        struct merge_transitions_impl<mp11::mp_list<Transitions...>>
-        {
-            using list = mp11::mp_list<Transitions...>;
-            using completion_event =
-                typename mp11::mp_first<list>::transition_event;
-            using type =
-                detail::transition_chain<derived_t, State, list, completion_event>;
-        };
-        template <typename Transitions>
-        using merge_transitions =
-            typename merge_transitions_impl<Transitions>::type;
-        using completion_transitions =
-            detail::completion_transitions<derived_t, State>;
-        using completion_transition = merge_transitions<completion_transitions>;
-
-      public:
-        completion_event_occurrence(uint8_t region_id)
-            : event_occurrence(&try_process), m_region_id(region_id)
-        {
-        }
-
-        static std::optional<process_result> try_process(
-            event_occurrence& self, void* processor,
-            uint16_t /*seq_cnt*/)
-        {
-            return static_cast<completion_event_occurrence&>(self)
-                .try_process_impl(static_cast<derived_t&>(
-                    *static_cast<event_pool_processor*>(processor)));
-        }
-
-      private:
-        std::optional<process_result> try_process_impl(derived_t& sm)
-        {
-            return sm.template process_completion_transition<
-                completion_transition>(m_region_id);
-        }
-
-        uint8_t m_region_id;
-    };
-
-    template <typename Transition>
-    process_result process_completion_transition(uint8_t region_id)
-    {
-        // If the state machine has terminate or interrupt flags, check them.
-        if constexpr (mp11::mp_any_of<state_set, detail::is_state_blocking>::value)
-        {
-            // If the state machine is interrupted or terminated, do not handle any event.
-            if (is_flag_active<TerminateFlag>() ||
-                is_flag_active<InterruptedFlag>())
-            {
-                return process_result::consumed;
-            }
-        }
-
-        // Process the event.
-        using completion_event = typename Transition::transition_event;
-        {
-            detail::process_guard guard{this->m_machine_state};
-            return Transition::process(self(), region_id, completion_event{});
-        }
-    }
-
     template <class Event>
     void do_defer_event(const Event& event, bool next_rtc_seq)
     {
@@ -750,7 +656,7 @@ class state_machine
                         m_self, m_region_id);
             }
             state.on_entry(m_event, m_self.get_fsm_argument());
-            m_self.template on_state_entry_completed<State>(m_region_id++);
+            m_self.template on_state_entry_completed<State>(state, m_region_id++);
             if constexpr (!std::is_same_v<observer_t, no_observer>)
             {
                 m_self.get_observer()
@@ -848,8 +754,93 @@ class state_machine
         process_event(event);
     }
 
+    // MSCV Bug:
+    // Compile error if this class is named completion_event.
+    template <typename State>
+    class completion_event_occurrence : public detail::event_occurrence
+    {
+        // Merge each list of transitions into a chain if needed.
+        template <typename Transitions>
+        struct merge_transitions_impl;
+        template <typename Transition>
+        struct merge_transitions_impl<mp11::mp_list<Transition>>
+        {
+            using type = Transition;
+        };
+        template <typename... Transitions>
+        struct merge_transitions_impl<mp11::mp_list<Transitions...>>
+        {
+            using list = mp11::mp_list<Transitions...>;
+            using completion_event =
+                typename mp11::mp_first<list>::transition_event;
+            using type =
+                detail::transition_chain<derived_t, State, list, completion_event>;
+        };
+        template <typename Transitions>
+        using merge_transitions =
+            typename merge_transitions_impl<Transitions>::type;
+        using completion_transitions =
+            detail::completion_transitions<derived_t, State>;
+        using completion_transition = merge_transitions<completion_transitions>;
+
+      public:
+        completion_event_occurrence(uint8_t region_id)
+            : event_occurrence(&try_process), m_region_id(region_id)
+        {
+        }
+
+        static std::optional<process_result> try_process(
+            event_occurrence& self, void* processor,
+            uint16_t /*seq_cnt*/)
+        {
+            return static_cast<completion_event_occurrence&>(self)
+                .try_process_impl(static_cast<derived_t&>(
+                    *static_cast<event_pool_processor*>(processor)));
+        }
+
+      private:
+        std::optional<process_result> try_process_impl(derived_t& sm)
+        {
+            using completion_event =
+                typename completion_transition::transition_event;
+            {
+                detail::process_guard guard{sm.m_machine_state};
+                return completion_transition::process(sm, m_region_id,
+                                                      completion_event{});
+            }
+        }
+
+      private:
+        uint8_t m_region_id;
+    };
+
+    class terminate_event : public detail::event_occurrence
+    {
+      public:
+        terminate_event() noexcept : event_occurrence(&try_process)
+        {
+        }
+
+        static std::optional<process_result> try_process(event_occurrence& self,
+                                                         void* processor,
+                                                         uint16_t /*seq_cnt*/)
+        {
+            return static_cast<terminate_event&>(self).try_process_impl(
+                static_cast<derived_t&>(
+                    *static_cast<event_pool_processor*>(processor)));
+        }
+
+        template <typename StateMachine>
+        std::optional<process_result> try_process_impl(StateMachine& sm)
+        {
+            auto root_sm = *(sm.m_root_sm);
+            root_sm->m_machine_state = machine_state::terminated;
+            return process_result::consumed;
+        }
+    };
+
     template <typename State>
-    void on_state_entry_completed(uint8_t region_id)
+    void on_state_entry_completed(const State&, uint8_t region_id)
     {
         // Exclude composite states from completion transitions,
         // these should fire when all their regions reach a final state
@@ -865,6 +856,13 @@ class state_machine
                 event_pool_processor::processable_event::make(
                     completion_event_occurrence<State>{region_id}));
         }
+        else if constexpr (mp11::mp_contains<detail::get_flag_list<State>,
+                                             TerminateFlag>::value)
+        {
+            auto& event_pool = this->get_event_pool();
+            event_pool.events.push_front(
+                event_pool_processor::processable_event::make(terminate_event{}));
+        }
     }
 
     template <class Event, class Fsm>
diff --git a/test/Backmp11.hpp b/test/Backmp11.hpp
index a2505dfb..3d4e0b48 100644
--- a/test/Backmp11.hpp
+++ b/test/Backmp11.hpp
@@ -10,8 +10,11 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include "boost/msm/backmp11/state_machine.hpp"
+#include "boost/msm/backmp11/observer.hpp"
 #include "boost/msm/backmp11/favor_compile_time.hpp" // IWYU pragma: keep
 
+#include "Utils.hpp"
+
 namespace boost::msm::backmp11
 {
 
@@ -34,4 +37,73 @@ class StateMachine
     }
 };
 
+class TestObserver : public default_observer
+{
+  public:
+    template <typename StateMachine, typename Event>
+    void post_process_event(const StateMachine&, const Event& event,
+                                      process_result result)
+    {
+        processed_events += 1;
+        if (expect_process_result &&
+            expect_process_result.value() != result)
+        {
+            const auto error = std::string{"\nUnexpected process result for "} +
+                               to_string(event) + "\n - expected: " +
+                               to_string(expect_process_result.value()) +
+                               "\n - actual: " + to_string(result);
+            BOOST_FAIL(error);
+        }
+    }
+
+    template <typename Source, typename Event, typename Target, typename Action,
+              typename Guard, typename StateMachine>
+    void post_process_transition(const StateMachine& sm, size_t /*region_id*/,
+                                 process_result result) const
+    {
+        assert_post_process_transition<Source, Event, Target, Action, Guard>(
+            sm, result);
+    }
+
+    template <typename Event, typename Action, typename Guard,
+              typename StateMachine>
+    void post_process_transition(const StateMachine& sm,
+                                           process_result result) const
+    {
+        assert_post_process_transition<StateMachine, Event, front::none, Action,
+                                       Guard>(sm, result);
+    }
+
+    size_t processed_events{};
+    std::optional<bool> expect_transition;
+    std::optional<process_result> expect_transition_result;
+    std::optional<process_result> expect_process_result;
+
+  private:
+    template <typename Source, typename Event, typename Target, typename Action,
+              typename Guard, typename StateMachine>
+    void assert_post_process_transition(const StateMachine& sm,
+                                        process_result result) const
+    {
+        const auto transition =
+            transition_to_string<Source, Event, Target, Action, Guard>(sm);
+        if (expect_transition && !expect_transition.value())
+        {
+            const auto error =
+                std::string{"\nUnexpected transition "} + transition;
+            BOOST_FAIL(error);
+        }
+        if (expect_transition_result &&
+            expect_transition_result.value() != result)
+        {
+            const auto error =
+                std::string{"\nUnexpected transition result for "} +
+                transition + "\n - expected: " +
+                to_string(expect_transition_result.value()) +
+                "\n - actual: " + to_string(result);
+            BOOST_FAIL(error);
+        }
+    }
+};
+
 } // boost::serialization
diff --git a/test/Backmp11MachineState.cpp b/test/Backmp11MachineState.cpp
new file mode 100644
index 00000000..215942b2
--- /dev/null
+++ b/test/Backmp11MachineState.cpp
@@ -0,0 +1,163 @@
+// Copyright 2026 Christian Granzin
+// Copyright 2010 Christophe Henry
+// henry UNDERSCORE christophe AT hotmail DOT com
+// This is an extended version of the state machine available in the boost::mpl library
+// Distributed under the same license as the original.
+// Copyright for the original version:
+// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
+// under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MSM_NONSTANDALONE_TEST
+#define BOOST_TEST_MODULE backmp11_observer_test
+#endif
+#include <boost/test/unit_test.hpp>
+
+#include "Backmp11.hpp"
+#include <boost/msm/backmp11/observer.hpp>
+
+#include "FrontCommon.hpp"
+#include "Utils.hpp"
+
+#include "attachments/backmp11/InterruptibleStateMachine.cpp"
+
+namespace msm = boost::msm;
+namespace mp11 = boost::mp11;
+
+using namespace msm::front;
+using namespace msm::backmp11;
+
+namespace
+{
+
+// Events.
+struct TerminateEvent {};
+
+// States.
+using MyTerminateState = terminate_state<>;
+
+// State machine.
+struct TestMachine_ : state_machine_def<TestMachine_>
+{
+    using initial_state = MyState;
+    using transition_table = mp11::mp_list<
+        Row<MyState         , TerminateEvent, MyTerminateState>,
+        Row<MyTerminateState, TerminateEvent, MyState>
+    >;
+    using internal_transition_table = mp11::mp_list<
+        Internal<SmInternalEvent>
+    >;
+};
+
+struct TestConfig : state_machine_config
+{
+    using observer = TestObserver;
+};
+
+struct TestFavorCompileTimeConfig : TestConfig
+{
+    using compile_policy = favor_compile_time;
+};
+
+template <typename Config = TestConfig>
+class TestMachine
+    : public state_machine<TestMachine_, Config, TestMachine<Config>>
+{
+    using Base = state_machine<TestMachine_, Config, TestMachine<Config>>;
+
+  public:
+    using Base::Base;
+
+    void interrupt()
+    {
+        m_interrupted = true;
+    }
+
+    void resume()
+    {
+        m_interrupted = false;
+        this->process_event_pool();
+    }
+
+    template <typename Event>
+    process_result process_event(const Event& event)
+    {
+        if (m_interrupted)
+        {
+            // Enqueue all events for later processing
+            // as long as the state machine is interrupted.
+            this->enqueue_event(event);
+            return process_result::deferred;
+        }
+        else
+        {
+            return Base::process_event(event);
+        }
+    }
+
+  private:
+    bool m_interrupted{};
+};
+
+using TestMachines = mp11::mp_list<
+    TestMachine<>,
+    TestMachine<TestFavorCompileTimeConfig>
+    >;
+
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(start_stop, StateMachine, TestMachines)
+{
+    StateMachine test_machine;
+    
+    BOOST_REQUIRE(test_machine.get_machine_state() == machine_state::stopped);
+    test_machine.start();
+    BOOST_REQUIRE(test_machine.get_machine_state() == machine_state::idle);
+    test_machine.stop();
+    BOOST_REQUIRE(test_machine.get_machine_state() == machine_state::stopped);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(terminate, StateMachine, TestMachines)
+{
+    StateMachine test_machine;
+    TestObserver& observer = test_machine.get_observer();
+    
+    test_machine.start();
+    BOOST_REQUIRE(test_machine.process_event(TerminateEvent{}) ==
+                  process_result::consumed);
+    ASSERT_ONE_AND_RESET(observer.processed_events);
+
+    observer.expect_transition = false;
+    BOOST_REQUIRE(test_machine.process_event(SmInternalEvent{}) ==
+                  process_result::discarded);
+    ASSERT_ONE_AND_RESET(observer.processed_events);
+}
+
+using InterruptibleTestMachines = mp11::mp_list<
+    InterruptibleStateMachine<TestConfig>,
+    InterruptibleStateMachine<TestFavorCompileTimeConfig>
+    >;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(interrupt, StateMachine, InterruptibleTestMachines)
+{
+    StateMachine test_machine;
+    TestObserver& observer = test_machine.get_observer();
+    PrintMessage::talk = false;
+    
+    test_machine.start();
+    BOOST_REQUIRE(test_machine.process_event(InterruptEvent{}) ==
+                  process_result::consumed);
+    ASSERT_ONE_AND_RESET(observer.processed_events);
+
+    BOOST_REQUIRE(test_machine.process_event(SmInternalEvent{}) ==
+                  process_result::deferred);
+    // The state machine extension intercepts the event.
+    ASSERT_ZERO(observer.processed_events);
+
+    observer.expect_transition = true;
+    observer.expect_process_result = process_result::consumed;
+    test_machine.resume();
+    ASSERT_ONE_AND_RESET(observer.processed_events);
+}
+
+} // namespace
diff --git a/test/Backmp11Serialization.cpp b/test/Backmp11Serialization.cpp
index c86179db..63a7a65e 100644
--- a/test/Backmp11Serialization.cpp
+++ b/test/Backmp11Serialization.cpp
@@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(boost_json)
     BOOST_REQUIRE(dim_switch.is_state_active<Off>());
 
     BOOST_REQUIRE(to_boost_json_string(dim_switch) == \
-R"({"front_end":{"brightness":0},"states":{"1":{"times_pressed":0}},"active_state_ids":[0],"stopped":false})");
+R"({"front_end":{"brightness":0},"states":{"1":{"times_pressed":0}},"active_state_ids":[0],"machine_state":1})");
 
     // Turn On (state id 1) and set brightness to 75.
     dim_switch.process_event(TurnOn{});
@@ -76,7 +76,7 @@ R"({"front_end":{"brightness":0},"states":{"1":{"times_pressed":0}},"active_stat
     BOOST_REQUIRE(dim_switch.brightness = 75);
 
     BOOST_REQUIRE(to_boost_json_string(dim_switch) == \
-R"({"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"stopped":false})");
+R"({"front_end":{"brightness":75},"states":{"1":{"times_pressed":1}},"active_state_ids":[1],"machine_state":1})");
 
     // Deserialize the json into a new state machine.
     const auto json = boost::json::parse(to_boost_json_string(dim_switch));
@@ -114,12 +114,12 @@ R"({
     "front_end": {
         "brightness": 0
     },
+    "machine_state": 1,
     "states": {
         "1": {
             "times_pressed": 0
         }
-    },
-    "stopped": false
+    }
 })");
 
     // Turn On (state id 1) and set brightness to 75.
@@ -137,12 +137,12 @@ R"({
     "front_end": {
         "brightness": 75
     },
+    "machine_state": 1,
     "states": {
         "1": {
             "times_pressed": 1
         }
-    },
-    "stopped": false
+    }
 })");
     
     // Deserialize the json into a new state machine.
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c93c3b44..824a3d4a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -88,6 +88,7 @@ add_executable(boost_msm_cxx17_tests
     Backmp11FunctorApi.cpp
     Backmp11Heapless.cpp
     Backmp11History.cpp
+    Backmp11MachineState.cpp
     Backmp11ManyDeferTransitions.cpp
     Backmp11Observer.cpp
     Backmp11RootSm.cpp
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index cb858681..2f067c10 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -88,6 +88,7 @@ test-suite msm-unit-tests-cxxstd17
     [ run Backmp11FunctorApi.cpp ]
     [ run Backmp11Heapless.cpp ]
     [ run Backmp11History.cpp ]
+    [ run Backmp11MachineState.cpp ]
     [ run Backmp11ManyDeferTransitions.cpp ]
     [ run Backmp11Observer.cpp ]
     [ run Backmp11RootSm.cpp ]
diff --git a/test/Utils.hpp b/test/Utils.hpp
index 9f9c9a39..8b61403b 100644
--- a/test/Utils.hpp
+++ b/test/Utils.hpp
@@ -9,6 +9,16 @@
 // file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#ifndef BOOST_MSM_TEST_UTILS_HPP
+#define BOOST_MSM_TEST_UTILS_HPP
+
+#include "boost/msm/front/states.hpp"
+#include <string>
+#include <any>
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/msm/backmp11/state_machine.hpp>
+
 #define ASSERT_ZERO(value) BOOST_REQUIRE(value == 0);
 
 #define ASSERT_AND_RESET(value, expected)                                      \
@@ -19,3 +29,109 @@
     BOOST_REQUIRE(value == 1);                                                 \
     value = 0
 
+namespace backmp11 = boost::msm::backmp11;
+namespace front = boost::msm::front;
+
+[[maybe_unused]] static std::string to_string(const std::type_info& type)
+{
+    auto full_name = boost::core::demangled_name(type);
+    return full_name.substr(full_name.rfind(':') + 1);
+}
+
+template <typename...>
+struct is_terminate_state : std::false_type {};
+
+template <typename Base, typename SmPtrPolicy>
+struct is_terminate_state<
+    front::terminate_state<Base, SmPtrPolicy>>
+    : std::true_type {};
+
+template <typename T>
+[[maybe_unused]] static std::string to_string()
+{
+    if constexpr (is_terminate_state<T>::value)
+    {
+        return "terminate_state";
+    }
+    else
+    {
+        return to_string(typeid(T));
+    }
+}
+
+template <typename FrontEnd, typename Config, typename Derived>
+[[maybe_unused]] static std::string to_string(
+    const backmp11::state_machine<FrontEnd, Config, Derived>& /*sm*/)
+{
+    return to_string<FrontEnd>();
+}
+
+template <typename T>
+[[maybe_unused]] static std::string to_string(const T& /*event*/)
+{
+    return to_string<T>();
+}
+
+[[maybe_unused]] static std::string to_string(const std::any& event)
+{
+    return to_string(event.type());
+}
+
+template <typename T>
+[[maybe_unused]] static std::string target_to_string()
+{
+    if constexpr (!std::is_same_v<T, front::none>)
+    {
+        return std::string{" -> "} + to_string<T>();
+    }
+    return {};
+}
+
+template <typename T>
+[[maybe_unused]] static std::string action_to_string()
+{
+    if constexpr (!std::is_same_v<T, front::none>)
+    {
+        return std::string{" / "} + to_string<T>();
+    }
+    return {};
+}
+
+template <typename T>
+[[maybe_unused]] static std::string guard_to_string()
+{
+    if constexpr (!std::is_same_v<T, front::none>)
+    {
+        return std::string{" [ "} + to_string<T>() + " ]";
+    }
+    return {};
+}
+
+[[maybe_unused]] static std::string to_string(backmp11::process_result result)
+{
+    using process_result = backmp11::process_result;
+    switch (result)
+    {
+        case process_result::discarded:
+            return "discarded";
+        case process_result::consumed:
+            return "consumed";
+        case process_result::rejected:
+            return "rejected";
+        case process_result::deferred:
+            return "deferred";
+        default:
+            return {};
+    }
+}
+
+template <typename Source, typename Event, typename Target, typename Action,
+            typename Guard, typename StateMachine>
+[[maybe_unused]] std::string transition_to_string(const StateMachine& sm)
+{
+    return to_string(sm) + ": \"" + to_string<Source>() + " + " +
+           to_string<Event>() + guard_to_string<Guard>() +
+           action_to_string<Action>() + target_to_string<Target>();
+}
+
+#endif // BOOST_MSM_TEST_UTILS_HPP

From a093e0aaca073b52e01c3ce6025cb40ea8995cfb Mon Sep 17 00:00:00 2001
From: Christian Granzin <christian.granzin@gmail.com>
Date: Thu, 18 Jun 2026 18:30:40 +0200
Subject: [PATCH 2/2] refactor(backmp11): try_process_thunk

---
 .../backmp11/detail/event_pool_processor.hpp  | 46 +++++++++----------
 include/boost/msm/backmp11/state_machine.hpp  | 36 +++++----------
 2 files changed, 35 insertions(+), 47 deletions(-)

diff --git a/include/boost/msm/backmp11/detail/event_pool_processor.hpp b/include/boost/msm/backmp11/detail/event_pool_processor.hpp
index 820fbfda..8d1a14c3 100644
--- a/include/boost/msm/backmp11/detail/event_pool_processor.hpp
+++ b/include/boost/msm/backmp11/detail/event_pool_processor.hpp
@@ -41,12 +41,7 @@ class event_occurrence
     // were not given and the event has not been dispatched.
     std::optional<process_result> try_process(void* processor, uint16_t seq_cnt)
     {
-        const auto result = m_process_fn(*this, processor, seq_cnt);
-        if (result)
-        {
-            m_process_fn = nullptr;
-        }
-        return result;
+        return m_process_fn(*this, processor, seq_cnt);
     }
 
     bool is_processed() const
@@ -54,6 +49,23 @@ class event_occurrence
         return m_process_fn == nullptr;
     }
 
+  protected:
+    template <typename Derived, typename StateMachine>
+    static std::optional<process_result> try_process_thunk(
+        event_occurrence& self, void* processor, uint16_t seq_cnt)
+    {
+        return static_cast<Derived&>(self).try_process(
+            static_cast<StateMachine&>(
+                *static_cast<typename StateMachine::event_pool_processor*>(
+                    processor)),
+            seq_cnt);
+    }
+
+    void mark_processed()
+    {
+        m_process_fn = nullptr;
+    }
+
   private:
     process_fn_t m_process_fn{};
 };
@@ -64,32 +76,20 @@ class deferred_event : public event_occurrence
   public:
     template <typename StateMachine>
     deferred_event(StateMachine&, const Event& event, uint16_t seq_cnt) noexcept
-        : event_occurrence(&try_process<StateMachine>), m_seq_cnt(seq_cnt),
-          m_event(event)
-    {
-    }
-
-    template <typename StateMachine>
-    static std::optional<process_result> try_process(event_occurrence& self,
-                                                     void* processor,
-                                                     uint16_t seq_cnt)
+        : event_occurrence(&try_process_thunk<deferred_event, StateMachine>),
+          m_seq_cnt(seq_cnt), m_event(event)
     {
-        return static_cast<deferred_event&>(self)
-            .try_process_impl<StateMachine>(
-                static_cast<StateMachine&>(
-                    *static_cast<typename StateMachine::event_pool_processor*>(
-                        processor)),
-                seq_cnt);
     }
 
     template <typename StateMachine>
-    std::optional<process_result> try_process_impl(StateMachine& sm,
-                                                   uint16_t seq_cnt)
+    std::optional<process_result> try_process(StateMachine& sm,
+                                              uint16_t seq_cnt)
     {
         if ((m_seq_cnt == seq_cnt) || sm.is_event_deferred(m_event))
         {
             return std::nullopt;
         }
+        mark_processed();
         return sm.process_event_observed(m_event, process_info::event_pool);
     }
 
diff --git a/include/boost/msm/backmp11/state_machine.hpp b/include/boost/msm/backmp11/state_machine.hpp
index 6bfe2357..8e966086 100644
--- a/include/boost/msm/backmp11/state_machine.hpp
+++ b/include/boost/msm/backmp11/state_machine.hpp
@@ -216,6 +216,7 @@ class state_machine
     template <typename, typename, template <typename> typename...>
     friend class detail::event_deferral_visitor;
 
+    friend class detail::event_occurrence;
     template <typename Event>
     friend class detail::deferred_event;
 
@@ -785,22 +786,16 @@ class state_machine
 
       public:
         completion_event_occurrence(uint8_t region_id)
-            : event_occurrence(&try_process), m_region_id(region_id)
+            : event_occurrence(
+                  &try_process_thunk<completion_event_occurrence, derived_t>),
+              m_region_id(region_id)
         {
         }
 
-        static std::optional<process_result> try_process(
-            event_occurrence& self, void* processor,
-            uint16_t /*seq_cnt*/)
-        {
-            return static_cast<completion_event_occurrence&>(self)
-                .try_process_impl(static_cast<derived_t&>(
-                    *static_cast<event_pool_processor*>(processor)));
-        }
-
-      private:
-        std::optional<process_result> try_process_impl(derived_t& sm)
+        std::optional<process_result> try_process(derived_t& sm,
+                                                  uint16_t /*seq_cnt*/)
         {
+            mark_processed();
             using completion_event =
                 typename completion_transition::transition_event;
             {
@@ -817,22 +812,15 @@ class state_machine
     class terminate_event : public detail::event_occurrence
     {
       public:
-        terminate_event() noexcept : event_occurrence(&try_process)
-        {
-        }
-
-        static std::optional<process_result> try_process(event_occurrence& self,
-                                                         void* processor,
-                                                         uint16_t /*seq_cnt*/)
+        terminate_event() noexcept
+            : event_occurrence(&try_process_thunk<terminate_event, derived_t>)
         {
-            return static_cast<terminate_event&>(self).try_process_impl(
-                static_cast<derived_t&>(
-                    *static_cast<event_pool_processor*>(processor)));
         }
 
-        template <typename StateMachine>
-        std::optional<process_result> try_process_impl(StateMachine& sm)
+        std::optional<process_result> try_process(derived_t& sm,
+                                                  uint16_t /*seq_cnt*/)
         {
+            mark_processed();
             auto root_sm = *(sm.m_root_sm);
             root_sm->m_machine_state = machine_state::terminated;
             return process_result::consumed;