Starting to process events in state machine instance.

diff --git a/include/rive/animation/event_bool_change.hpp b/include/rive/animation/event_bool_change.hpp
index 79d3933..61f79a2 100644
--- a/include/rive/animation/event_bool_change.hpp
+++ b/include/rive/animation/event_bool_change.hpp

@@ -1,10 +1,12 @@
 #ifndef _RIVE_EVENT_BOOL_CHANGE_HPP_
 #define _RIVE_EVENT_BOOL_CHANGE_HPP_
 #include "rive/generated/animation/event_bool_change_base.hpp"
-#include <stdio.h>
+
 namespace rive {
     class EventBoolChange : public EventBoolChangeBase {
     public:
+        bool validateInputType(const StateMachineInput* input) const override;
+        void perform(StateMachineInstance* stateMachineInstance) const override;
     };
 } // namespace rive
 

diff --git a/include/rive/animation/event_input_change.hpp b/include/rive/animation/event_input_change.hpp
index ee3e724..b3ae0ce 100644
--- a/include/rive/animation/event_input_change.hpp
+++ b/include/rive/animation/event_input_change.hpp

@@ -3,9 +3,13 @@
 #include "rive/generated/animation/event_input_change_base.hpp"
 
 namespace rive {
+    class StateMachineInstance;
+    class StateMachineInput;
     class EventInputChange : public EventInputChangeBase {
     public:
         StatusCode import(ImportStack& importStack) override;
+        virtual void perform(StateMachineInstance* stateMachineInstance) const = 0;
+        virtual bool validateInputType(const StateMachineInput* input) const { return true; }
     };
 } // namespace rive
 

diff --git a/include/rive/animation/event_number_change.hpp b/include/rive/animation/event_number_change.hpp
index 27ac05f..6e123d0 100644
--- a/include/rive/animation/event_number_change.hpp
+++ b/include/rive/animation/event_number_change.hpp

@@ -1,10 +1,12 @@
 #ifndef _RIVE_EVENT_NUMBER_CHANGE_HPP_
 #define _RIVE_EVENT_NUMBER_CHANGE_HPP_
 #include "rive/generated/animation/event_number_change_base.hpp"
-#include <stdio.h>
+
 namespace rive {
     class EventNumberChange : public EventNumberChangeBase {
     public:
+        bool validateInputType(const StateMachineInput* input) const override;
+        void perform(StateMachineInstance* stateMachineInstance) const override;
     };
 } // namespace rive
 

diff --git a/include/rive/animation/event_trigger_change.hpp b/include/rive/animation/event_trigger_change.hpp
index b6245af..20200b5 100644
--- a/include/rive/animation/event_trigger_change.hpp
+++ b/include/rive/animation/event_trigger_change.hpp

@@ -1,10 +1,12 @@
 #ifndef _RIVE_EVENT_TRIGGER_CHANGE_HPP_
 #define _RIVE_EVENT_TRIGGER_CHANGE_HPP_
 #include "rive/generated/animation/event_trigger_change_base.hpp"
-#include <stdio.h>
+
 namespace rive {
     class EventTriggerChange : public EventTriggerChangeBase {
     public:
+        bool validateInputType(const StateMachineInput* input) const override;
+        void perform(StateMachineInstance* stateMachineInstance) const override;
     };
 } // namespace rive
 

diff --git a/include/rive/animation/state_machine_event.hpp b/include/rive/animation/state_machine_event.hpp
index b3d7606..ea6cb5a 100644
--- a/include/rive/animation/state_machine_event.hpp
+++ b/include/rive/animation/state_machine_event.hpp

@@ -1,21 +1,30 @@
 #ifndef _RIVE_STATE_MACHINE_EVENT_HPP_
 #define _RIVE_STATE_MACHINE_EVENT_HPP_
 #include "rive/generated/animation/state_machine_event_base.hpp"
+#include "rive/event_type.hpp"
 
 namespace rive {
+    class Shape;
     class StateMachineEventImporter;
     class EventInputChange;
+    class StateMachineInstance;
     class StateMachineEvent : public StateMachineEventBase {
         friend class StateMachineEventImporter;
 
     private:
+        std::vector<uint32_t> m_HitShapesIds;
         std::vector<EventInputChange*> m_InputChanges;
         void addInputChange(EventInputChange* inputChange);
 
     public:
+        EventType eventType() const { return (EventType)eventTypeValue(); }
         size_t inputChangeCount() const { return m_InputChanges.size(); }
         const EventInputChange* inputChange(size_t index) const;
         StatusCode import(ImportStack& importStack) override;
+        StatusCode onAddedClean(CoreContext* context) override;
+
+        const std::vector<uint32_t>& hitShapeIds() const { return m_HitShapesIds; }
+        void performChanges(StateMachineInstance* stateMachineInstance) const;
     };
 } // namespace rive
 

diff --git a/include/rive/animation/state_machine_instance.hpp b/include/rive/animation/state_machine_instance.hpp
index 2226ef9..b995265 100644
--- a/include/rive/animation/state_machine_instance.hpp
+++ b/include/rive/animation/state_machine_instance.hpp

@@ -3,7 +3,9 @@
 
 #include <string>
 #include <stddef.h>
+#include <vector>
 #include "rive/animation/linear_animation_instance.hpp"
+#include "rive/event_type.hpp"
 
 namespace rive {
     class StateMachine;
@@ -13,8 +15,9 @@
     class SMIBool;
     class SMINumber;
     class SMITrigger;
-
+    class Shape;
     class StateMachineLayerInstance;
+    class HitShape;
 
     class StateMachineInstance {
         friend class SMIInput;
@@ -31,6 +34,9 @@
 
         void markNeedsAdvance();
 
+        std::vector<HitShape*> m_HitShapes;
+        void processEvent(Vec2D position, EventType hitEvent);
+
     public:
         StateMachineInstance(const StateMachine* machine, ArtboardInstance* instance);
         ~StateMachineInstance();

diff --git a/include/rive/artboard.hpp b/include/rive/artboard.hpp
index ad19de3..297cedb 100644
--- a/include/rive/artboard.hpp
+++ b/include/rive/artboard.hpp

@@ -67,6 +67,7 @@
         StatusCode initialize();
 
         Core* resolve(uint32_t id) const override;
+        uint32_t idOf(Core* object) const;
 
         // EXPERIMENTAL -- for internal testing only for now.
         // DO NOT RELY ON THIS as it may change/disappear in the future.
@@ -88,7 +89,7 @@
 
         // Returns true iff calling popMessage() will return true.
         bool hasMessages() const;
-        
+
         // If there are any queued messages...
         //   copies the first message into msg parameter
         //   removes that message from the queue
@@ -138,6 +139,16 @@
         StateMachine* stateMachine(std::string name) const;
         StateMachine* stateMachine(size_t index) const;
 
+        /// Make an instance of a state machine given the name of the source state machine in this
+        /// artboard. The StateMachineInstance must be explictly deleted when no longer needed.
+        StateMachineInstance* stateMachineInstance(std::string name);
+
+        /// Make an instance of a state machine given the index of the source state machine in this
+        /// artboard. The StateMachineInstance must be explictly deleted when no longer needed.
+        StateMachineInstance* stateMachineInstance(size_t index);
+
+        size_t stateMachineCount() const { return m_StateMachines.size(); }
+
         /// Make an instance of this artboard, must be explictly deleted when no
         /// longer needed.
         // Deprecated...

diff --git a/include/rive/event_type.hpp b/include/rive/event_type.hpp
new file mode 100644
index 0000000..d50df00
--- /dev/null
+++ b/include/rive/event_type.hpp

@@ -0,0 +1,11 @@
+#ifndef _RIVE_EVENT_TYPE_HPP_
+#define _RIVE_EVENT_TYPE_HPP_
+namespace rive {
+    enum class EventType : unsigned int {
+        enter = 0,
+        exit = 1,
+        down = 2,
+        up = 3,
+    };
+}
+#endif
\ No newline at end of file

diff --git a/include/rive/generated/animation/event_input_change_base.hpp b/include/rive/generated/animation/event_input_change_base.hpp
index 61f30d1..7212efb 100644
--- a/include/rive/generated/animation/event_input_change_base.hpp
+++ b/include/rive/generated/animation/event_input_change_base.hpp

@@ -26,11 +26,11 @@
         static const uint16_t inputIdPropertyKey = 227;
 
     private:
-        int m_InputId = -1;
+        uint32_t m_InputId = -1;
 
     public:
-        inline int inputId() const { return m_InputId; }
-        void inputId(int value) {
+        inline uint32_t inputId() const { return m_InputId; }
+        void inputId(uint32_t value) {
             if (m_InputId == value) {
                 return;
             }

diff --git a/include/rive/generated/animation/state_machine_event_base.hpp b/include/rive/generated/animation/state_machine_event_base.hpp
index 2aa9f01..a67e39c 100644
--- a/include/rive/generated/animation/state_machine_event_base.hpp
+++ b/include/rive/generated/animation/state_machine_event_base.hpp

@@ -28,12 +28,12 @@
         static const uint16_t eventTypeValuePropertyKey = 225;
 
     private:
-        int m_TargetId = 0;
-        int m_EventTypeValue = 0;
+        uint32_t m_TargetId = 0;
+        uint32_t m_EventTypeValue = 0;
 
     public:
-        inline int targetId() const { return m_TargetId; }
-        void targetId(int value) {
+        inline uint32_t targetId() const { return m_TargetId; }
+        void targetId(uint32_t value) {
             if (m_TargetId == value) {
                 return;
             }
@@ -41,8 +41,8 @@
             targetIdChanged();
         }
 
-        inline int eventTypeValue() const { return m_EventTypeValue; }
-        void eventTypeValue(int value) {
+        inline uint32_t eventTypeValue() const { return m_EventTypeValue; }
+        void eventTypeValue(uint32_t value) {
             if (m_EventTypeValue == value) {
                 return;
             }

diff --git a/src/animation/event_bool_change.cpp b/src/animation/event_bool_change.cpp
new file mode 100644
index 0000000..946f15a
--- /dev/null
+++ b/src/animation/event_bool_change.cpp

@@ -0,0 +1,22 @@
+#include "rive/animation/event_bool_change.hpp"
+#include "rive/animation/state_machine_instance.hpp"
+#include "rive/animation/state_machine_bool.hpp"
+#include "rive/animation/state_machine_input_instance.hpp"
+using namespace rive;
+
+bool EventBoolChange::validateInputType(const StateMachineInput* input) const {
+    // A null input is valid as the StateMachine can attempt to limp along if we
+    // introduce new input types that old conditions are expected to handle in
+    // newer runtimes. The older runtimes will just evaluate them to true.
+    return input == nullptr || input->is<StateMachineBool>();
+}
+
+void EventBoolChange::perform(StateMachineInstance* stateMachineInstance) const {
+    auto inputInstance = stateMachineInstance->input(inputId());
+    if (inputInstance == nullptr) {
+        return;
+    }
+    // If it's not null, it must be our correct type (why we validate at load time).
+    auto boolInput = reinterpret_cast<SMIBool*>(inputInstance);
+    boolInput->value(value());
+}
\ No newline at end of file

diff --git a/src/animation/event_input_change.cpp b/src/animation/event_input_change.cpp
index d319855..7914ae3 100644
--- a/src/animation/event_input_change.cpp
+++ b/src/animation/event_input_change.cpp

@@ -1,17 +1,27 @@
 #include "rive/animation/state_machine_event.hpp"
 #include "rive/importers/import_stack.hpp"
 #include "rive/importers/state_machine_event_importer.hpp"
+#include "rive/importers/state_machine_importer.hpp"
 #include "rive/animation/event_input_change.hpp"
-#include "rive/generated/animation/state_machine_base.hpp"
+#include "rive/animation/state_machine.hpp"
 
 using namespace rive;
 
 StatusCode EventInputChange::import(ImportStack& importStack) {
+    auto stateMachineImporter = importStack.latest<StateMachineImporter>(StateMachine::typeKey);
+    if (stateMachineImporter == nullptr) {
+        return StatusCode::MissingObject;
+    }
+
     auto stateMachineEventImporter =
         importStack.latest<StateMachineEventImporter>(StateMachineEventBase::typeKey);
     if (stateMachineEventImporter == nullptr) {
         return StatusCode::MissingObject;
     }
+
+    if (!validateInputType(stateMachineImporter->stateMachine()->input((size_t)inputId()))) {
+        return StatusCode::InvalidObject;
+    }
     stateMachineEventImporter->addInputChange(this);
     return Super::import(importStack);
 }

diff --git a/src/animation/event_number_change.cpp b/src/animation/event_number_change.cpp
new file mode 100644
index 0000000..a97d306
--- /dev/null
+++ b/src/animation/event_number_change.cpp

@@ -0,0 +1,23 @@
+#include "rive/animation/event_number_change.hpp"
+#include "rive/animation/state_machine_instance.hpp"
+#include "rive/animation/state_machine_number.hpp"
+#include "rive/animation/state_machine_input_instance.hpp"
+
+using namespace rive;
+
+bool EventNumberChange::validateInputType(const StateMachineInput* input) const {
+    // A null input is valid as the StateMachine can attempt to limp along if we
+    // introduce new input types that old conditions are expected to handle in
+    // newer runtimes. The older runtimes will just evaluate them to true.
+    return input == nullptr || input->is<StateMachineNumber>();
+}
+
+void EventNumberChange::perform(StateMachineInstance* stateMachineInstance) const {
+    auto inputInstance = stateMachineInstance->input(inputId());
+    if (inputInstance == nullptr) {
+        return;
+    }
+    // If it's not null, it must be our correct type (why we validate at load time).
+    auto numberInput = reinterpret_cast<SMINumber*>(inputInstance);
+    numberInput->value(value());
+}

diff --git a/src/animation/event_trigger_change.cpp b/src/animation/event_trigger_change.cpp
new file mode 100644
index 0000000..e2b8d9d
--- /dev/null
+++ b/src/animation/event_trigger_change.cpp

@@ -0,0 +1,23 @@
+#include "rive/animation/event_trigger_change.hpp"
+#include "rive/animation/state_machine_instance.hpp"
+#include "rive/animation/state_machine_trigger.hpp"
+#include "rive/animation/state_machine_input_instance.hpp"
+
+using namespace rive;
+
+bool EventTriggerChange::validateInputType(const StateMachineInput* input) const {
+    // A null input is valid as the StateMachine can attempt to limp along if we
+    // introduce new input types that old conditions are expected to handle in
+    // newer runtimes. The older runtimes will just evaluate them to true.
+    return input == nullptr || input->is<StateMachineTrigger>();
+}
+
+void EventTriggerChange::perform(StateMachineInstance* stateMachineInstance) const {
+    auto inputInstance = stateMachineInstance->input(inputId());
+    if (inputInstance == nullptr) {
+        return;
+    }
+    // If it's not null, it must be our correct type (why we validate at load time).
+    auto triggerInput = reinterpret_cast<SMITrigger*>(inputInstance);
+    triggerInput->fire();
+}
\ No newline at end of file

diff --git a/src/animation/state_machine_event.cpp b/src/animation/state_machine_event.cpp
index d6791b3..fd367ed 100644
--- a/src/animation/state_machine_event.cpp
+++ b/src/animation/state_machine_event.cpp

@@ -2,6 +2,10 @@
 #include "rive/importers/import_stack.hpp"
 #include "rive/importers/state_machine_importer.hpp"
 #include "rive/generated/animation/state_machine_base.hpp"
+#include "rive/artboard.hpp"
+#include "rive/shapes/shape.hpp"
+#include "rive/animation/state_machine_instance.hpp"
+#include "rive/animation/event_input_change.hpp"
 
 using namespace rive;
 
@@ -23,4 +27,34 @@
         return m_InputChanges[index];
     }
     return nullptr;
+}
+
+StatusCode StateMachineEvent::onAddedClean(CoreContext* context) {
+    auto artboard = static_cast<Artboard*>(context);
+    for (auto core : artboard->objects()) {
+        if (core == nullptr) {
+            continue;
+        }
+        auto target = artboard->resolve(targetId());
+
+        // Iterate artboard to find Shapes that are parented to the target
+        if (core->is<Shape>()) {
+            auto shape = core->as<Shape>();
+            for (ContainerComponent* component = shape; component != nullptr;
+                 component = component->parent()) {
+                if (component == target) {
+                    m_HitShapesIds.push_back(artboard->idOf(shape));
+                    break;
+                }
+            }
+        }
+    }
+
+    return Super::onAddedClean(context);
+}
+
+void StateMachineEvent::performChanges(StateMachineInstance* stateMachineInstance) const {
+    for (auto inputChange : m_InputChanges) {
+        inputChange->perform(stateMachineInstance);
+    }
 }
\ No newline at end of file

diff --git a/src/animation/state_machine_instance.cpp b/src/animation/state_machine_instance.cpp
index b5bfa84..1129c4f 100644
--- a/src/animation/state_machine_instance.cpp
+++ b/src/animation/state_machine_instance.cpp

@@ -13,6 +13,10 @@
 #include "rive/animation/animation_state.hpp"
 #include "rive/animation/state_instance.hpp"
 #include "rive/animation/animation_state_instance.hpp"
+#include "rive/animation/state_machine_event.hpp"
+#include "rive/shapes/shape.hpp"
+#include "rive/math/aabb.hpp"
+#include <unordered_map>
 
 using namespace rive;
 namespace rive {
@@ -69,7 +73,7 @@
             }
         }
 
-        bool advance(/*Artboard* artboard, */float seconds, SMIInput** inputs, size_t inputCount) {
+        bool advance(/*Artboard* artboard, */ float seconds, SMIInput** inputs, size_t inputCount) {
             m_StateChangedOnAdvance = false;
 
             if (m_CurrentState != nullptr) {
@@ -124,7 +128,8 @@
             if ((m_CurrentState == nullptr ? nullptr : m_CurrentState->state()) == stateTo) {
                 return false;
             }
-            m_CurrentState = stateTo == nullptr ? nullptr : stateTo->makeInstance(m_ArtboardInstance).release();
+            m_CurrentState =
+                stateTo == nullptr ? nullptr : stateTo->makeInstance(m_ArtboardInstance).release();
             return true;
         }
 
@@ -213,12 +218,62 @@
             return static_cast<AnimationStateInstance*>(m_CurrentState)->animationInstance();
         }
     };
+
+    /// Representation of a Shape from the Artboard Instance and all the events it
+    /// triggers. Allows tracking hover and performing hit detection only once on
+    /// shapes that trigger multiple events.
+    class HitShape {
+    private:
+        Shape* m_Shape;
+
+    public:
+        Shape* shape() const { return m_Shape; }
+        HitShape(Shape* shape) : m_Shape(shape) {}
+        bool isHovered = false;
+        std::vector<const StateMachineEvent*> events;
+    };
 } // namespace rive
 
-StateMachineInstance::StateMachineInstance(const StateMachine* machine, ArtboardInstance* instance)
-        : m_Machine(machine)
-        , m_ArtboardInstance(instance)
-{
+void StateMachineInstance::processEvent(Vec2D position, EventType hitEvent) {
+    const int hitRadius = 2;
+    auto hitArea = AABB(position.x() - hitRadius,
+                        position.y() - hitRadius,
+                        position.x() + hitRadius,
+                        position.y() + hitRadius)
+                       .round();
+    for (auto hitShape : m_HitShapes) {
+
+        // TODO: quick reject.
+
+        // TODO: hit test
+        bool isOver = false;
+
+        bool hoverChange = hitShape->isHovered != isOver;
+        hitShape->isHovered = isOver;
+        // iterate all events associated with this hit shape
+        for (auto event : hitShape->events) {
+            // Always update hover states regardless of which specific event type
+            // we're trying to trigger.
+            if (hoverChange) {
+                if (isOver && event->eventType() == EventType::enter) {
+                    event->performChanges(this);
+                    markNeedsAdvance();
+                } else if (!isOver && event->eventType() == EventType::exit) {
+                    event->performChanges(this);
+                    markNeedsAdvance();
+                }
+            }
+            if (isOver && hitEvent == event->eventType()) {
+                event->performChanges(this);
+                markNeedsAdvance();
+            }
+        }
+    }
+}
+
+StateMachineInstance::StateMachineInstance(const StateMachine* machine,
+                                           ArtboardInstance* instance) :
+    m_Machine(machine), m_ArtboardInstance(instance) {
     assert(instance->isInstance());
     m_InputCount = machine->inputCount();
     m_InputInstances = new SMIInput*[m_InputCount];
@@ -250,9 +305,40 @@
     for (size_t i = 0; i < m_LayerCount; i++) {
         m_Layers[i].init(machine->layer(i), m_ArtboardInstance);
     }
+
+    // Initialize events. Store a lookup table of shape id to hit shape
+    // representation (an object that stores all the events triggered by the
+    // shape producing an event).
+    std::unordered_map<uint32_t, HitShape*> hitShapeLookup;
+    for (std::size_t i = 0; i < machine->eventCount(); i++) {
+        auto event = machine->event(i);
+
+        // Iterate actual leaf hittable shapes tied to this event and resolve
+        // corresponding ones in the artboard instance.
+        for (auto id : event->hitShapeIds()) {
+            HitShape* hitShape;
+            auto itr = hitShapeLookup.find(id);
+            if (itr == hitShapeLookup.end()) {
+                auto shape = artboard->resolve(id);
+                if (shape != nullptr && shape->is<Shape>()) {
+                    hitShapeLookup[id] = hitShape = new HitShape(shape->as<Shape>());
+                    m_HitShapes.push_back(hitShape);
+                } else {
+                    // No object or not a shape...
+                    continue;
+                }
+            } else {
+                hitShape = itr->second;
+            }
+            hitShape->events.push_back(event);
+        }
+    }
 }
 
 StateMachineInstance::~StateMachineInstance() {
+    for (auto hitShape : m_HitShapes) {
+        delete hitShape;
+    }
     // TODO: can this and others be rewritten as for (auto inst : m_InputInstances) ?
     for (size_t i = 0; i < m_InputCount; i++) {
         delete m_InputInstances[i];
@@ -279,9 +365,7 @@
 void StateMachineInstance::markNeedsAdvance() { m_NeedsAdvance = true; }
 bool StateMachineInstance::needsAdvance() const { return m_NeedsAdvance; }
 
-std::string StateMachineInstance::name() const {
-    return m_Machine->name();
-}
+std::string StateMachineInstance::name() const { return m_Machine->name(); }
 
 SMIInput* StateMachineInstance::input(size_t index) const {
     if (index < m_InputCount) {

diff --git a/src/artboard.cpp b/src/artboard.cpp
index 940b835..b52587f 100644
--- a/src/artboard.cpp
+++ b/src/artboard.cpp

@@ -14,6 +14,7 @@
 #include "rive/importers/import_stack.hpp"
 #include "rive/importers/backboard_importer.hpp"
 #include "rive/nested_artboard.hpp"
+#include "rive/animation/state_machine_instance.hpp"
 
 #include <stack>
 #include <unordered_map>
@@ -287,6 +288,8 @@
     return m_Objects[id];
 }
 
+uint32_t Artboard::idOf(Core* object) const { return 0; }
+
 void Artboard::onComponentDirty(Component* component) {
     m_Dirt |= ComponentDirt::Components;
 
@@ -506,6 +509,22 @@
     return m_StateMachines[index];
 }
 
+StateMachineInstance* Artboard::stateMachineInstance(std::string name) {
+    StateMachine* machine = stateMachine(name);
+    if (machine != nullptr) {
+        return new StateMachineInstance(machine, this);
+    }
+    return nullptr;
+}
+
+StateMachineInstance* Artboard::stateMachineInstance(size_t index) {
+    StateMachine* machine = stateMachine(index);
+    if (machine != nullptr) {
+        return new StateMachineInstance(machine, this);
+    }
+    return nullptr;
+}
+
 std::unique_ptr<ArtboardInstance> Artboard::instance() const {
     std::unique_ptr<ArtboardInstance> artboardClone(new ArtboardInstance);
     artboardClone->copy(*this);
@@ -577,7 +596,8 @@
                 assert(gButtonIsDown);
                 gButtonIsDown = false;
                 break;
-            default: break;
+            default:
+                break;
         }
 
 #if 0
@@ -603,13 +623,9 @@
 #endif
 }
 
-void Artboard::testing_only_enque_message(const Message& msg) {
-    m_MessageQueue.push(msg);
-}
+void Artboard::testing_only_enque_message(const Message& msg) { m_MessageQueue.push(msg); }
 
-bool Artboard::hasMessages() const {
-    return !m_MessageQueue.empty();
-}
+bool Artboard::hasMessages() const { return !m_MessageQueue.empty(); }
 
 bool Artboard::nextMessage(Message* msg) {
     if (m_MessageQueue.empty()) {
@@ -626,26 +642,22 @@
 #include "rive/animation/linear_animation_instance.hpp"
 #include "rive/animation/state_machine_instance.hpp"
 
-std::unique_ptr<LinearAnimationInstance>
-ArtboardInstance::animationAt(size_t index) {
+std::unique_ptr<LinearAnimationInstance> ArtboardInstance::animationAt(size_t index) {
     auto la = this->animation(index);
     return la ? std::make_unique<LinearAnimationInstance>(la, this) : nullptr;
 }
 
-std::unique_ptr<LinearAnimationInstance>
-ArtboardInstance::animationNamed(std::string name) {
+std::unique_ptr<LinearAnimationInstance> ArtboardInstance::animationNamed(std::string name) {
     auto la = this->animation(name);
     return la ? std::make_unique<LinearAnimationInstance>(la, this) : nullptr;
 }
 
-std::unique_ptr<StateMachineInstance>
-ArtboardInstance::stateMachineAt(size_t index) {
+std::unique_ptr<StateMachineInstance> ArtboardInstance::stateMachineAt(size_t index) {
     auto sm = this->stateMachine(index);
     return sm ? std::make_unique<StateMachineInstance>(sm, this) : nullptr;
 }
 
-std::unique_ptr<StateMachineInstance>
-ArtboardInstance::stateMachineNamed(std::string name) {
+std::unique_ptr<StateMachineInstance> ArtboardInstance::stateMachineNamed(std::string name) {
     auto sm = this->stateMachine(name);
     return sm ? std::make_unique<StateMachineInstance>(sm, this) : nullptr;
 }

diff --git a/test/state_machine_test.cpp b/test/state_machine_test.cpp
index b4b0f97..3424c5f 100644
--- a/test/state_machine_test.cpp
+++ b/test/state_machine_test.cpp

@@ -73,6 +73,7 @@
 
     auto abi = artboard->instance();
     rive::StateMachineInstance smi(artboard->stateMachine("Button"), abi.get());
+
     REQUIRE(smi.getBool("Hover")->name() == "Hover");
     REQUIRE(smi.getBool("Press")->name() == "Press");
     REQUIRE(smi.getBool("Hover") != nullptr);