diff --git a/source/Lite.StateMachine.BenchmarkTests/BasicStateBenchmarks.cs b/source/Lite.StateMachine.BenchmarkTests/BasicStateBenchmarks.cs
index b08dd47..cec6db3 100644
--- a/source/Lite.StateMachine.BenchmarkTests/BasicStateBenchmarks.cs
+++ b/source/Lite.StateMachine.BenchmarkTests/BasicStateBenchmarks.cs
@@ -43,7 +43,7 @@ public async Task BasicStatesRunsAsync()
   }
 
   [Benchmark]
-  public void FlatStateMachineRunsSync()
+  public void BasicStatesRunsSync()
   {
     var maxCounter = CyclesBeforeExit;
     PropertyBag parameters = new()
diff --git a/source/Lite.StateMachine.Tests/StateTests/CustomStateTests.cs b/source/Lite.StateMachine.Tests/StateTests/CustomStateTests.cs
new file mode 100644
index 0000000..67080d3
--- /dev/null
+++ b/source/Lite.StateMachine.Tests/StateTests/CustomStateTests.cs
@@ -0,0 +1,137 @@
+// Copyright Xeno Innovations, Inc. 2025
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading.Tasks;
+using Lite.StateMachine.Tests.TestData;
+using Lite.StateMachine.Tests.TestData.Services;
+using Lite.StateMachine.Tests.TestData.States.CustomStates;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Lite.StateMachine.Tests.StateTests;
+
+[TestClass]
+public class CustomStateTests : TestBase
+{
+  public TestContext TestContext { get; set; }
+
+  [TestMethod]
+  [DataRow(false, DisplayName = "Don't skip State3")]
+  [DataRow(true, DisplayName = "Skip State3")]
+  public async Task BasicState_Override_Executes_SuccessAsync(bool skipState3)
+  {
+    // Assemble with Dependency Injection
+    var services = new ServiceCollection()
+      //// Register Services
+      .AddLogging(InlineTraceLogger(LogLevel.None))
+      .AddSingleton<IMessageService, MessageService>()
+      .BuildServiceProvider();
+
+    var msgService = services.GetRequiredService<IMessageService>();
+    Func<Type, object?> factory = t => ActivatorUtilities.CreateInstance(services, t);
+
+    var ctxProperties = new PropertyBag()
+    {
+      { ParameterType.Counter, 0 },
+      { ParameterType.TestExitEarly, skipState3 },
+    };
+
+    var machine = new StateMachine<CustomStateId>(factory, null, isContextPersistent: true);
+    machine.RegisterState<State1>(CustomStateId.State1, CustomStateId.State2_Dummy);
+    machine.RegisterState<State2Dummy>(CustomStateId.State2_Dummy, CustomStateId.State3);
+    machine.RegisterState<State2Success>(CustomStateId.State2_Success, CustomStateId.State3);
+    machine.RegisterState<State3>(CustomStateId.State3);
+
+    // Act - Start your engine!
+    await machine.RunAsync(CustomStateId.State1, ctxProperties, cancellationToken: TestContext.CancellationToken);
+
+    // Assert Results
+    Assert.IsNotNull(machine);
+    Assert.IsNull(machine.Context);
+
+    Assert.AreEqual(1, msgService.Counter1);
+    Assert.AreEqual(0, msgService.Counter2, "State2Dummy should never enter");
+    Assert.AreEqual(skipState3 ? 0 : 1, msgService.Counter3);
+  }
+
+  [TestMethod]
+  public async Task BasicState_Overrides_ThrowUnregisteredException_Async()
+  {
+    // Assemble with Dependency Injection
+    var services = new ServiceCollection()
+      //// Register Services
+      .AddLogging(InlineTraceLogger(LogLevel.None))
+      .AddSingleton<IMessageService, MessageService>()
+      .BuildServiceProvider();
+
+    var msgService = services.GetRequiredService<IMessageService>();
+    Func<Type, object?> factory = t => ActivatorUtilities.CreateInstance(services, t);
+
+    var ctxProperties = new PropertyBag()
+    {
+      { ParameterType.Counter, 0 },
+      { ParameterType.TestUnregisteredTransition, true },
+    };
+
+    var machine = new StateMachine<CustomStateId>(factory, null, isContextPersistent: true);
+    machine.RegisterState<State1>(CustomStateId.State1, CustomStateId.State2_Dummy);
+    machine.RegisterState<State2Dummy>(CustomStateId.State2_Dummy, CustomStateId.State3);
+    machine.RegisterState<State2Success>(CustomStateId.State2_Success, CustomStateId.State3);
+    machine.RegisterState<State3>(CustomStateId.State3);
+
+    // Act - Start your engine!
+    await Assert.ThrowsExactlyAsync<UnregisteredStateTransitionException>(()
+      => machine.RunAsync(CustomStateId.State1, ctxProperties, null, TestContext.CancellationToken));
+
+    // Assert Results
+    Assert.IsNotNull(machine);
+    Assert.IsNull(machine.Context);
+
+    Assert.AreEqual(0, msgService.Counter1);
+    Assert.AreEqual(0, msgService.Counter2, "State2Dummy should never enter");
+  }
+
+  [TestMethod]
+  [DataRow(false, DisplayName = "Run State2_Sub3")]
+  [DataRow(true, DisplayName = "Skip State2_Sub3")]
+  public async Task Composite_Override_Executes_SuccessAsync(bool skipSubState3)
+  {
+    // Assemble with Dependency Injection
+    var services = new ServiceCollection()
+      //// Register Services
+      .AddLogging(InlineTraceLogger(LogLevel.Trace))
+      .AddSingleton<IMessageService, MessageService>()
+      .BuildServiceProvider();
+
+    var msgService = services.GetRequiredService<IMessageService>();
+    Func<Type, object?> factory = t => ActivatorUtilities.CreateInstance(services, t);
+
+    var ctxProperties = new PropertyBag()
+    {
+      { ParameterType.Counter, 0 },
+      { ParameterType.TestExitEarly2, skipSubState3 },
+    };
+
+    var machine = new StateMachine<CustomStateId>(factory, null, isContextPersistent: true);
+
+    machine.RegisterState<State1>(CustomStateId.State1, CustomStateId.State2_Dummy);
+    machine.RegisterState<State2Dummy>(CustomStateId.State2_Dummy, CustomStateId.State3);
+    machine.RegisterComposite<State2Success>(CustomStateId.State2_Success, CustomStateId.State2_Sub1, CustomStateId.State3);
+    machine.RegisterSubState<State2Success_Sub1>(CustomStateId.State2_Sub1, CustomStateId.State2_Success, CustomStateId.State2_Sub2);
+    machine.RegisterSubState<State2Success_Sub2>(CustomStateId.State2_Sub2, CustomStateId.State2_Success, CustomStateId.State2_Sub3);
+    machine.RegisterSubState<State2Success_Sub3>(CustomStateId.State2_Sub3, CustomStateId.State2_Success);
+    machine.RegisterState<State3>(CustomStateId.State3);
+
+    // Act - Start your engine!
+    await machine.RunAsync(CustomStateId.State1, ctxProperties, cancellationToken: TestContext.CancellationToken);
+
+    // Assert Results
+    Assert.IsNotNull(machine);
+    Assert.IsNull(machine.Context);
+
+    Assert.AreEqual(skipSubState3 ? 2 : 3, msgService.Counter1, "State Counter1 failed.");
+    Assert.AreEqual(0, msgService.Counter2, "State2Dummy should never enter");
+    Assert.AreEqual(1, msgService.Counter3, "Skip Substate Counter3 failed");
+  }
+}
diff --git a/source/Lite.StateMachine.Tests/DiTests/MsDiTests.cs b/source/Lite.StateMachine.Tests/StateTests/DiMsTests.cs
similarity index 98%
rename from source/Lite.StateMachine.Tests/DiTests/MsDiTests.cs
rename to source/Lite.StateMachine.Tests/StateTests/DiMsTests.cs
index c95cdfd..463a7bd 100644
--- a/source/Lite.StateMachine.Tests/DiTests/MsDiTests.cs
+++ b/source/Lite.StateMachine.Tests/StateTests/DiMsTests.cs
@@ -13,11 +13,12 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
 
-namespace Lite.StateMachine.Tests.DiTests;
+namespace Lite.StateMachine.Tests.StateTests;
 
+/// <summary>Microsoft Dependency Injection Tests.</summary>
 [TestClass]
 [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1124:Do not use regions", Justification = "Allowed for this test class")]
-public class MsDiTests
+public class DiMsTests
 {
   [TestMethod]
   public async Task Basic_FlatStates_SuccessTestAsync()
@@ -197,7 +198,7 @@ public async Task RegisterState_MsDi_EventAggregatorOnly_SuccessTestAsync()
 
     var aggregator = services.GetRequiredService<IEventAggregator>();
     var msgService = services.GetRequiredService<IMessageService>();
-    var logService = services.GetRequiredService<ILogger<MsDiTests>>();
+    var logService = services.GetRequiredService<ILogger<DiMsTests>>();
 
     msgService.Counter1 = 0;
     msgService.Counter2 = 0;
diff --git a/source/Lite.StateMachine.Tests/TestData/ParameterType.cs b/source/Lite.StateMachine.Tests/TestData/ParameterType.cs
index 735ec89..1083087 100644
--- a/source/Lite.StateMachine.Tests/TestData/ParameterType.cs
+++ b/source/Lite.StateMachine.Tests/TestData/ParameterType.cs
@@ -3,9 +3,23 @@
 
 namespace Lite.StateMachine.Tests.TestData;
 
-public static class ParameterType
+public enum ParameterType
 {
-  public const string Counter = "Counter";
-  public const string HungStateAvoidance = "DoNotAllowHungStatesTest";
-  public const string KeyTest = "TestKey";
+  /// <summary>Generic counter.</summary>
+  Counter,
+
+  /// <summary>Tests for DoNotAllowHungStatesTest.</summary>
+  HungStateAvoidance,
+
+  /// <summary>Random test.</summary>
+  KeyTest,
+
+  /// <summary>Test triggers an early exit. Setting OnSuccess to NULL.</summary>
+  TestExitEarly,
+
+  /// <summary>Test triggers a 2nd early exit. Setting OnSuccess to NULL.</summary>
+  TestExitEarly2,
+
+  /// <summary>Test trigger to go to an invalid state transition.</summary>
+  TestUnregisteredTransition,
 }
diff --git a/source/Lite.StateMachine.Tests/TestData/States/StateEnums.cs b/source/Lite.StateMachine.Tests/TestData/StateEnums.cs
similarity index 65%
rename from source/Lite.StateMachine.Tests/TestData/States/StateEnums.cs
rename to source/Lite.StateMachine.Tests/TestData/StateEnums.cs
index 2c50f98..a69907a 100644
--- a/source/Lite.StateMachine.Tests/TestData/States/StateEnums.cs
+++ b/source/Lite.StateMachine.Tests/TestData/StateEnums.cs
@@ -1,7 +1,7 @@
 // Copyright Xeno Innovations, Inc. 2025
 // See the LICENSE file in the project root for more information.
 
-namespace Lite.StateMachine.Tests.TestData.States;
+namespace Lite.StateMachine.Tests.TestData;
 
 #pragma warning disable SA1649 // File name should match first type name
 
@@ -46,4 +46,24 @@ public enum CompositeMsgStateId
   Failure,
 }
 
+public enum CustomStateId
+{
+  /// <summary>Initial state.</summary>
+  State1,
+
+  /// <summary>Dummy state that is registered but never transitioned to.</summary>
+  State2_Dummy,
+
+  State2_Success,
+
+  /// <summary>This state must NEVER be registered.</summary>
+  State2_Unregistered,
+
+  State2_Sub1,
+  State2_Sub2,
+  State2_Sub3,
+
+  State3,
+}
+
 #pragma warning restore SA1649 // File name should match first type name
diff --git a/source/Lite.StateMachine.Tests/TestData/States/CustomBasicStates.cs b/source/Lite.StateMachine.Tests/TestData/States/CustomBasicStates.cs
new file mode 100644
index 0000000..9a4338e
--- /dev/null
+++ b/source/Lite.StateMachine.Tests/TestData/States/CustomBasicStates.cs
@@ -0,0 +1,139 @@
+// Copyright Xeno Innovations, Inc. 2025
+// See the LICENSE file in the project root for more information.
+
+using System.Threading.Tasks;
+using Lite.StateMachine.Tests.TestData.Services;
+
+#pragma warning disable SA1649 // File name should match first type name
+#pragma warning disable SA1402 // File may only contain a single type
+#pragma warning disable IDE0130 // Namespace does not match folder structure
+
+namespace Lite.StateMachine.Tests.TestData.States.CustomStates;
+
+public class State1 : StateBase<State1, CustomStateId>
+{
+  public State1() => HasDebugLogging = true;
+
+  public override async Task OnEnter(Context<CustomStateId> ctx)
+  {
+    int cnt = ctx.ParameterAsInt(ParameterType.Counter);
+
+    if (ctx.ParameterAsBool(ParameterType.TestUnregisteredTransition))
+      ctx.NextStates.OnSuccess = CustomStateId.State2_Unregistered;
+    else
+      ctx.NextStates.OnSuccess = CustomStateId.State2_Success;
+
+    await base.OnEnter(ctx);
+  }
+}
+
+/// <summary>This state should NEVER be transitioned into.</summary>
+public class State2Dummy : StateBase<State2Dummy, CustomStateId>
+{
+  private readonly IMessageService _msgService;
+
+  public State2Dummy(IMessageService msg)
+  {
+    _msgService = msg;
+    HasDebugLogging = true;
+  }
+
+  public override Task OnEnter(Context<CustomStateId> context)
+  {
+    Assert.Fail("Overridden state transitions should not all us to be here.");
+    _msgService.Counter2++;
+    return base.OnEnter(context);
+  }
+}
+
+public class State2Success : StateBase<State2Success, CustomStateId>
+{
+  private readonly IMessageService _msgService;
+
+  public State2Success(IMessageService msg)
+  {
+    _msgService = msg;
+    HasDebugLogging = true;
+  }
+
+  public override Task OnEnter(Context<CustomStateId> ctx)
+  {
+    _msgService.Counter1++;
+
+    if (ctx.ParameterAsBool(ParameterType.TestExitEarly))
+      ctx.NextStates.OnSuccess = null;
+
+    return base.OnEnter(ctx);
+  }
+
+  public override Task OnExit(Context<CustomStateId> context)
+  {
+    // When operating as a Composite, we need to pass back Success.
+    context.NextState(Result.Success);
+    return base.OnExit(context);
+  }
+}
+
+public class State2Success_Sub1 : StateBase<State2Success_Sub1, CustomStateId>
+{
+  public State2Success_Sub1() => HasDebugLogging = true;
+}
+
+public class State2Success_Sub2 : StateBase<State2Success_Sub2, CustomStateId>
+{
+  private readonly IMessageService _msgService;
+
+  public State2Success_Sub2(IMessageService msg)
+  {
+    _msgService = msg;
+    HasDebugLogging = true;
+  }
+
+  public override Task OnEnter(Context<CustomStateId> ctx)
+  {
+    _msgService.Counter1++;
+
+    if (ctx.ParameterAsBool(ParameterType.TestExitEarly2))
+      ctx.NextStates.OnSuccess = null;
+
+    return base.OnEnter(ctx);
+  }
+}
+
+public class State2Success_Sub3 : StateBase<State2Success_Sub3, CustomStateId>
+{
+  private readonly IMessageService _msgService;
+
+  public State2Success_Sub3(IMessageService msg)
+  {
+    _msgService = msg;
+    HasDebugLogging = true;
+  }
+
+  public override Task OnEnter(Context<CustomStateId> ctx)
+  {
+    _msgService.Counter1++;
+    return base.OnEnter(ctx);
+  }
+}
+
+public class State3 : StateBase<State3, CustomStateId>
+{
+  private readonly IMessageService _msgService;
+
+  public State3(IMessageService msg)
+  {
+    _msgService = msg;
+    HasDebugLogging = true;
+  }
+
+  public override Task OnEnter(Context<CustomStateId> ctx)
+  {
+    _msgService.Counter3++;
+    return base.OnEnter(ctx);
+  }
+}
+
+#pragma warning restore IDE0130 // Namespace does not match folder structure
+#pragma warning restore SA1649 // File name should match first type name
+#pragma warning restore SA1402 // File may only contain a single type
diff --git a/source/Lite.StateMachine.Tests/TestData/States/StateBase.cs b/source/Lite.StateMachine.Tests/TestData/States/StateBase.cs
index a3401aa..70c9371 100644
--- a/source/Lite.StateMachine.Tests/TestData/States/StateBase.cs
+++ b/source/Lite.StateMachine.Tests/TestData/States/StateBase.cs
@@ -2,6 +2,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics;
 using System.Threading.Tasks;
 
 namespace Lite.StateMachine.Tests.TestData.States;
@@ -9,15 +10,30 @@ namespace Lite.StateMachine.Tests.TestData.States;
 public class StateBase<TStateClass, TStateId> : IState<TStateId>
   where TStateId : struct, Enum
 {
+  public bool HasDebugLogging { get; set; } = false;
+
   public virtual Task OnEnter(Context<TStateId> context)
   {
+    if (HasDebugLogging)
+      Debug.WriteLine($"[{GetType().Name}] [OnEnter]");
+
     context.NextState(Result.Success);
     return Task.CompletedTask;
   }
 
-  public virtual Task OnEntering(Context<TStateId> context) =>
-    Task.CompletedTask;
+  public virtual Task OnEntering(Context<TStateId> context)
+  {
+    if (HasDebugLogging)
+      Debug.WriteLine($"[{GetType().Name}] [OnEntering]");
+
+    return Task.CompletedTask;
+  }
+
+  public virtual Task OnExit(Context<TStateId> context)
+  {
+    if (HasDebugLogging)
+      Debug.WriteLine($"[{GetType().Name}] [OnExit]");
 
-  public virtual Task OnExit(Context<TStateId> context) =>
-    Task.CompletedTask;
+    return Task.CompletedTask;
+  }
 }
diff --git a/source/Lite.StateMachine/Context.cs b/source/Lite.StateMachine/Context.cs
index 5a00372..6ad01c6 100644
--- a/source/Lite.StateMachine/Context.cs
+++ b/source/Lite.StateMachine/Context.cs
@@ -11,15 +11,25 @@ namespace Lite.StateMachine;
 public sealed class Context<TStateId>
   where TStateId : struct, Enum
 {
+#pragma warning disable SA1401 // Fields should be private
+
+  /// <summary>Mapping of the next state transitions for this state.</summary>
+  /// <remarks>Optionally override your next transitions.</remarks>
+  public StateMap<TStateId> NextStates;
+
+#pragma warning restore SA1401 // Fields should be private
+
   private readonly TaskCompletionSource<Result> _tcs;
 
   internal Context(
     TStateId current,
+    StateMap<TStateId> nextStates,
     TaskCompletionSource<Result> tcs,
     IEventAggregator? eventAggregator = null,
     Result? lastChildResult = null)
   {
     CurrentStateId = current;
+    NextStates = nextStates;
     _tcs = tcs;
     EventAggregator = eventAggregator;
     LastChildResult = lastChildResult;
@@ -38,23 +48,16 @@ internal Context(
   public Result? LastChildResult { get; }
 
   /////// <summary>Gets the previous state's enum value.</summary>
-  ////public TStateId LastStateId { get; internal set; }
+  ////public TStateId PreviousState { get; internal set; }
 
   /// <summary>Gets or sets an arbitrary parameter provided by caller to the current action.</summary>
   public PropertyBag Parameters { get; set; } = [];
 
   /// <summary>Signal the machine to move forward (only once per state entry).</summary>
   /// <param name="result">Result to pass to the next state.</param>
+  /// <remarks>Consider renaming to `StateResult` or `Result` for clarity.</remarks>
   public void NextState(Result result) => _tcs.TrySetResult(result);
 
-  /// <summary>Override the previously defined <see cref="NextState(Result)"/> transition with the one specified.</summary>
-  /// <param name="result">On <see cref="Result"/> value.</param>
-  /// <param name="newStateId">New <see cref="TStateId"/> to transition to.</param>
-  public void OnTransition(Result result, TStateId newStateId)
-  {
-    throw new NotImplementedException();
-  }
-
   public bool ParameterAsBool(object key, bool defaultBool = false)
   {
     if (Parameters.TryGetValue(key, out var value) && value is bool boolValue)
diff --git a/source/Lite.StateMachine/Lite.StateMachine.csproj b/source/Lite.StateMachine/Lite.StateMachine.csproj
index 9f72f4f..e149f26 100644
--- a/source/Lite.StateMachine/Lite.StateMachine.csproj
+++ b/source/Lite.StateMachine/Lite.StateMachine.csproj
@@ -11,7 +11,7 @@
     <AssemblyVersion>2.2.0</AssemblyVersion>
     <FileVersion>$(AssemblyVersion)</FileVersion>
     <VersionPrefix>$(AssemblyVersion)</VersionPrefix>
-    <VersionSuffix>-alpha1</VersionSuffix>
+    <VersionSuffix>-alpha2</VersionSuffix>
     <Version>$(VersionPrefix)$(VersionSuffix)</Version>
 
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
@@ -21,10 +21,17 @@
     <RepositoryUrl>https://github.com/SuessLabs/Lite.StateMachine</RepositoryUrl>
     <PackageTags>statemachine;lite;fsm;suesslabs;xeno-innovations</PackageTags>
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
-    <PackageReleaseNotes>New features in v2.1:
+    <PackageReleaseNotes>
+      New Features in v2.2:
 
-* Proprety: IsContextPersistent - Auto-cleans Context parameters added by substates.
-* Renamed `RegisterCompositeChild(...)` to `RegisterSubComposite(...)`</PackageReleaseNotes>
+      * New: Renamed, Result.Ok -&gt; Result.Success (Breaking Change).
+      * New: Renamed, Context.ErrorStaack -&gt; Context.Errors (Breaking Change).
+      * New: Context.NextStates provides ability to override the next transitions for a state.
+
+      New Features in v2.1:
+
+      * Proprety: IsContextPersistent - Auto-cleans Context parameters added by substates.
+      * Renamed `RegisterCompositeChild(...)` to `RegisterSubComposite(...)` (breaking change)</PackageReleaseNotes>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
diff --git a/source/Lite.StateMachine/StateMachine.cs b/source/Lite.StateMachine/StateMachine.cs
index f4eaf5a..76cf441 100644
--- a/source/Lite.StateMachine/StateMachine.cs
+++ b/source/Lite.StateMachine/StateMachine.cs
@@ -301,8 +301,15 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
     // Composite States
     var instance = GetOrCreateInstance(reg);
 
+    StateMap<TStateId> nextStates = new()
+    {
+      OnSuccess = reg.OnSuccess,
+      OnError = reg.OnError,
+      OnFailure = reg.OnFailure,
+    };
+
     var parentEnterTcs = new TaskCompletionSource<Result>(TaskCreationOptions.RunContinuationsAsynchronously);
-    var parentEnterCtx = new Context<TStateId>(reg.StateId, parentEnterTcs, _eventAggregator)
+    var parentEnterCtx = new Context<TStateId>(reg.StateId, nextStates, parentEnterTcs, _eventAggregator)
     {
       Parameters = parameters,
       Errors = errors,
@@ -321,6 +328,11 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
 
     await instance.OnEnter(parentEnterCtx).ConfigureAwait(false);
 
+    // Check for next transition overrides
+    ////reg.OnSuccess = parentEnterCtx.NextStates.OnSuccess;
+    ////reg.OnError = parentEnterCtx.NextStates.OnError;
+    ////reg.OnFailure = parentEnterCtx.NextStates.OnFailure;
+
     // TODO (2025-12-28 DS): Consider StateMachine config param to just move along or throw exception
     if (reg.InitialChildId is null)
       throw new MissingInitialSubStateException($"Composite '{reg.StateId}' must have an initial child (InitialChildId).");
@@ -348,6 +360,7 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
       if (childResult is null)
         return null;
 
+      // TODO (#76): Extract the Context.OnSuccess/Error/Failure override (if any)
       lastChildResult = childResult;
       var nextChildId = ResolveNext(childReg, childResult.Value);
 
@@ -367,7 +380,7 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
     // Parent's OnExit decides Ok/Error/Failure; Inform parent of last child's result via Context
     // TODO (2025-12-28 DS): Pass one Context object. Just clear "lastChildResult" after the OnExit.
     var parentExitTcs = new TaskCompletionSource<Result>(TaskCreationOptions.RunContinuationsAsynchronously);
-    var parentExitCtx = new Context<TStateId>(reg.StateId, parentExitTcs, _eventAggregator, lastChildResult)
+    var parentExitCtx = new Context<TStateId>(reg.StateId, nextStates, parentExitTcs, _eventAggregator, lastChildResult)
     {
       Parameters = parameters ?? [],
       Errors = errors ?? [],
@@ -409,8 +422,17 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
     CancellationToken cancellationToken)
   {
     IState<TStateId> instance = GetOrCreateInstance(reg);
+
+    // Next state transitions
+    StateMap<TStateId> nextStates = new()
+    {
+      OnSuccess = reg.OnSuccess,
+      OnError = reg.OnError,
+      OnFailure = reg.OnFailure,
+    };
+
     var tcs = new TaskCompletionSource<Result>(TaskCreationOptions.RunContinuationsAsynchronously);
-    var ctx = new Context<TStateId>(reg.StateId, tcs, _eventAggregator)
+    var ctx = new Context<TStateId>(reg.StateId, nextStates, tcs, _eventAggregator)
     {
       Parameters = parameterStack ?? [],
       Errors = errorStack ?? [],
@@ -443,7 +465,9 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
             {
               await Task.Delay(timeoutMs, timeoutCts.Token).ConfigureAwait(false);
               if (!tcs.Task.IsCompleted && !timeoutCts.IsCancellationRequested)
+              {
                 await cmd.OnTimeout(ctx).ConfigureAwait(false);
+              }
             }
             catch (TaskCanceledException)
             {
@@ -463,10 +487,16 @@ private StateRegistration<TStateId> GetRegistration(TStateId stateId)
       var result = await WaitForNextOrCancelAsync(tcs.Task, cancellationToken).ConfigureAwait(false);
 
       // TODO (2025-12-28 DS): Potential DefaultStateTimeoutMs. Even leaving OnEnter without NextState(Result.OK), should consider calling `OnExit` to allow states to cleanup.
+      // TODO (2026-01-04 DS): Consider handling "OnTRANSITION" overrides. Passing a single Context would solve this as it's passed by ref.
       if (result is null)
         return null;
 
       await instance.OnExit(ctx).ConfigureAwait(false);
+
+      reg.OnSuccess = ctx.NextStates.OnSuccess;
+      reg.OnError = ctx.NextStates.OnError;
+      reg.OnFailure = ctx.NextStates.OnFailure;
+
       return result.Value;
     }
     finally
diff --git a/source/Lite.StateMachine/StateMap.cs b/source/Lite.StateMachine/StateMap.cs
new file mode 100644
index 0000000..2fefd3c
--- /dev/null
+++ b/source/Lite.StateMachine/StateMap.cs
@@ -0,0 +1,15 @@
+// Copyright Xeno Innovations, Inc. 2025
+// See the LICENSE file in the project root for more information.
+
+// <Auto-Generated>This is here so CodeMaid doesn't reorganize this document.</Auto-Generated>
+using System;
+
+namespace Lite.StateMachine;
+
+public struct StateMap<TStateId>
+  where TStateId : struct, Enum
+{
+  public TStateId? OnSuccess;
+  public TStateId? OnError;
+  public TStateId? OnFailure;
+}