diff --git a/Include/Aurora/Async/IWorkItemHandler.hpp b/Include/Aurora/Async/IWorkItemHandler.hpp
index 0fa410b6..fe2f1fbd 100644
--- a/Include/Aurora/Async/IWorkItemHandler.hpp
+++ b/Include/Aurora/Async/IWorkItemHandler.hpp
@@ -29,8 +29,10 @@ namespace Aurora::Async
 
             EProcessNext type;
             AuList<AuSPtr<IWorkItem>> waitFor;
-            AuUInt32 reschedMs;
-            AuUInt64 reschedNs;
+            AuUInt32 reschedMs {};
+            AuUInt64 reschedNs {};
+            AuUInt32 reschedClockAbsMs {};
+            AuUInt64 reschedClockAbsNs {};
             // @hideinitializer
             IThreadPool *pool;
         };
diff --git a/Include/Aurora/Async/Jobs.hpp b/Include/Aurora/Async/Jobs.hpp
index 49704b0d..f782e1d3 100644
--- a/Include/Aurora/Async/Jobs.hpp
+++ b/Include/Aurora/Async/Jobs.hpp
@@ -18,8 +18,6 @@ namespace Aurora::Async
         AuFunction<void(const Info_t &, const Result_t &)> onSuccess;
         AuFunction<void(const Info_t &)>                   onFailure;
     };
-    
-    using FVoidJob = FJob<AVoid, AVoid>;
 
     template<class Info_t = AVoid, class Result_t = AVoid>
     struct CJob
@@ -30,4 +28,6 @@ namespace Aurora::Async
         void(* onSuccess)(const Info_t &, const Result_t &);
         void(* onFailure)(const Info_t &);
     };
+    
+    using FVoidJob = FJob<AVoid, AVoid>;
 }
\ No newline at end of file
diff --git a/Include/Aurora/Async/WorkBasic.hpp b/Include/Aurora/Async/WorkBasic.hpp
index 559ebf63..d384295d 100644
--- a/Include/Aurora/Async/WorkBasic.hpp
+++ b/Include/Aurora/Async/WorkBasic.hpp
@@ -12,44 +12,44 @@ namespace Aurora::Async
     
     /// --- THREAD POOL -- 
 
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &>
-    static AuSPtr<IWorkItem> NewWork(const WorkerPId_t &worker, a task, b job, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)>
+    static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false)
     {                                                                                                                                               
         return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait);                                    
     }                                                                                                                                               
                                                                                                                                                     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &>
-    static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_t &worker, a task, b job, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)>
+    static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c> 
-    static AuSPtr<IWorkItem> NewWork(const WorkerPId_t &worker, a task, b job, c info, bool enableWait = false)                                       
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
+    static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)                                       
     {                                                                                                                                                
         return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);                               
     }                                                                                                                                                
                                                                                                                                                      
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c> 
-    static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_t &worker, a task, b job, c info, bool enableWait = false)                                  
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
+    static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)                                  
     {                                                                                                                                                
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();                                            
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchFunctional(const WorkerPId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)>
+    AuSPtr<IWorkItem> DispatchFunctional(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchFunctor(const WorkerPId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)>
+    AuSPtr<IWorkItem> DispatchFunctor(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchVoid(const WorkerPId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)>
+    AuSPtr<IWorkItem> DispatchVoid(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
@@ -57,44 +57,44 @@ namespace Aurora::Async
 
     /// --- ASYNC APP -- 
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &>
-    static AuSPtr<IWorkItem> NewWork(const WorkerId_t &worker, a task, b job, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
+    static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false)
     {                                                                                                                                               
         return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait);                                    
     }                                                                                                                                               
                                                                                                                                                     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &>
-    static AuSPtr<IWorkItem> DispatchWork(const WorkerId_t &worker, a task, b job, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
+    static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c> 
-    static AuSPtr<IWorkItem> NewWork(const WorkerId_t &worker, a task, b job, c info, bool enableWait = false)                                       
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
+    static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)                                       
     {                                                                                                                                                
         return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);                               
     }                                                                                                                                                
                                                                                                                                                      
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c> 
-    static AuSPtr<IWorkItem> DispatchWork(const WorkerId_t &worker, a task, b job, c info, bool enableWait = false)                                  
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
+    static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)                                  
     {                                                                                                                                                
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();                                            
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchFunctional(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
+    AuSPtr<IWorkItem> DispatchFunctional(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchFunctor(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
+    AuSPtr<IWorkItem> DispatchFunctor(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
-    
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &>
-    AuSPtr<IWorkItem> DispatchVoid(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
+    AuSPtr<IWorkItem> DispatchVoid(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
diff --git a/Include/Aurora/Async/WorkPairImpl.hpp b/Include/Aurora/Async/WorkPairImpl.hpp
index da2ca95c..1f9dd0d3 100644
--- a/Include/Aurora/Async/WorkPairImpl.hpp
+++ b/Include/Aurora/Async/WorkPairImpl.hpp
@@ -227,8 +227,8 @@ namespace Aurora::Async
 
     private:
         
-        static constexpr bool IsCallbackPtr = std::is_pointer_v<Job_t>  || AuIsBaseOfTemplate<AuSPtr, Job_t>::value  || AuIsBaseOfTemplate<AuUPtr, Job_t>::value;
-        static constexpr bool IsTaskPtr     = std::is_pointer_v<Task_t> || AuIsBaseOfTemplate<AuSPtr, Task_t>::value || AuIsBaseOfTemplate<AuUPtr, Task_t>::value;
+        static constexpr bool IsCallbackPtr = std::is_pointer_v<Job_t>  || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Job_t>::value  || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Job_t>::value;
+        static constexpr bool IsTaskPtr     = std::is_pointer_v<Task_t> || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Task_t>::value || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Task_t>::value;
 
         //WorkerId_t caller;
         WorkerPId_t caller_;
diff --git a/Source/Async/WorkItem.cpp b/Source/Async/WorkItem.cpp
index e5f5ca32..fcf5f814 100644
--- a/Source/Async/WorkItem.cpp
+++ b/Source/Async/WorkItem.cpp
@@ -226,11 +226,19 @@ namespace Aurora::Async
             if (info.reschedMs)
             {
                 SetSchedTime(info.reschedMs);
-            }
-            if (info.reschedNs)
+            } 
+            else if (info.reschedNs)
             {
                 SetSchedTimeNs(info.reschedNs);
             }
+            else if (info.reschedClockAbsMs)
+            {
+                SetSchedTimeAbs(info.reschedMs);
+            }
+            else if (info.reschedClockAbsNs)
+            {
+                SetSchedTimeNsAbs(info.reschedNs);
+            }
             WaitFor(info.waitFor);
 
         }
diff --git a/Source/Console/Commands/Commands.cpp b/Source/Console/Commands/Commands.cpp
index 92a90f9d..ed5fc364 100644
--- a/Source/Console/Commands/Commands.cpp
+++ b/Source/Console/Commands/Commands.cpp
@@ -110,7 +110,7 @@ namespace Aurora::Console::Commands
                 {
                     dispatch.callback->OnCommand(dispatch.arguments);
                 }),
-                {},
+                AuAsync::FJob<CommandDispatch>{},
                 CommandDispatch(res.result, callback),
                 false
             );