The task and thread families are plain ksys::

They link in the same block as the plain-ksys:: Message family.
getItemValue and applyScreenFade sit in engine UI TUs, hence ksys::ui.

(AI assisted using Claude Fable 5.1 and Claude Opus 5.5)

14 files changed, 56 insertions, 58 deletions

diff --git a/src/KingSystem/ActorSystem/actActorCreator.cpp b/src/KingSystem/ActorSystem/actActorCreator.cpp
index 5bb3303d..32556639 100644
--- a/src/KingSystem/ActorSystem/actActorCreator.cpp
+++ b/src/KingSystem/ActorSystem/actActorCreator.cpp
@@ -23,7 +23,7 @@ ActorCreator::ActorCreator() {
     mPlacementMgrHeap = nullptr;
 }
 
-void ActorCreator::onTaskRemoved(const util::TaskRemoveCallbackContext& context) {
+void ActorCreator::onTaskRemoved(const TaskRemoveCallbackContext& context) {
     if (!context.mTask)
         return;
 
diff --git a/src/KingSystem/ActorSystem/actActorCreator.h b/src/KingSystem/ActorSystem/actActorCreator.h
index 3368e765..7560230d 100644
--- a/src/KingSystem/ActorSystem/actActorCreator.h
+++ b/src/KingSystem/ActorSystem/actActorCreator.h
@@ -67,7 +67,7 @@ private:
                            InstParamPack* params, bool sleep_after_init, bool = false);
 
     BaseProc* doCreateProc(BaseProcCreateArg& arg);
-    void onTaskRemoved(const util::TaskRemoveCallbackContext& context);
+    void onTaskRemoved(const TaskRemoveCallbackContext& context);
 
     sead::Heap* mForBaseProcDualHeap;
     sead::Heap* mPlacementMgrHeap;
@@ -79,8 +79,7 @@ private:
     void* _60{};
     sead::Delegate1R<ActorCreator, BaseProcCreateArg&, BaseProc*> mCreateProcDelegate{
         this, &ActorCreator::doCreateProc};
-    util::TaskRemoveCallbackT<ActorCreator> mTaskRemovedDelegate{this,
-                                                                 &ActorCreator::onTaskRemoved};
+    TaskRemoveCallbackT<ActorCreator> mTaskRemovedDelegate{this, &ActorCreator::onTaskRemoved};
     sead::CriticalSection mActorListCS;
     ActorFactory* mActorFactory;
 };
diff --git a/src/KingSystem/ActorSystem/actActorParam.h b/src/KingSystem/ActorSystem/actActorParam.h
index a1796eca..6e869b57 100644
--- a/src/KingSystem/ActorSystem/actActorParam.h
+++ b/src/KingSystem/ActorSystem/actActorParam.h
@@ -175,8 +175,8 @@ private:
     std::array<s32, 2> mNumHandles;
     s32 mRefCount{};
     sead::CriticalSection mCS{nullptr};
-    util::Event mEvent{nullptr,
-                       sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, true};
+    Event mEvent{nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified,
+                 true};
 };
 KSYS_CHECK_SIZE_NX150(ActorParam, 0x200);
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp b/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
index b2d623fc..ab52e12a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
@@ -75,7 +75,7 @@ void BaseProcCreateTask::doPrepare(const BaseProcCreateTaskData* arg) {
     }();
 }
 
-void BaseProcCreateTask::prepareImpl_(util::TaskRequest* req) {
+void BaseProcCreateTask::prepareImpl_(TaskRequest* req) {
     doPrepare(sead::DynamicCast<BaseProcCreateTaskRequest>(req)->mData);
     setDelegateInternal_(&mTaskDelegate);
 }
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTask.h b/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
index 50c1c966..fcffd092 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
@@ -33,8 +33,8 @@ struct BaseProcCreateArg {
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateArg, 0x58);
 
-class BaseProcCreateTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskData, util::TaskData)
+class BaseProcCreateTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskData, TaskData)
 
 public:
     BaseProcCreateTaskData() = default;
@@ -53,8 +53,8 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateTaskData, 0x68);
 
-class BaseProcCreateTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskRequest, util::TaskRequest)
+class BaseProcCreateTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskRequest, TaskRequest)
 
 public:
     BaseProcCreateTaskRequest() = default;
@@ -62,8 +62,8 @@ public:
     BaseProcCreateTaskData* mData{};
 };
 
-class BaseProcCreateTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTask, util::ManagedTask)
+class BaseProcCreateTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTask, ManagedTask)
 
 public:
     enum class LaneId : u8 {
@@ -77,7 +77,7 @@ public:
     void onBaseProcCreationFailed(BaseProc* proc, bool set_flag_5);
 
 protected:
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
 
 private:
     friend class BaseProcCreateTaskSelector;
@@ -92,8 +92,8 @@ private:
     sead::IDelegate1R<BaseProcCreateArg&, BaseProc*>* mCreateDelegate{};
     BaseProcUnit* mUnit{};
     map::Object* mMapObject{};
-    util::TaskDelegateT<BaseProcCreateTask> mTaskDelegate{
-        this, &BaseProcCreateTask::onTaskDelegateInvoked};
+    TaskDelegateT<BaseProcCreateTask> mTaskDelegate{this,
+                                                    &BaseProcCreateTask::onTaskDelegateInvoked};
     BaseProcLink mLink;
     f32 mDistanceToLoadSphere = -1.0;
     InstParamPack::Buffer mParams;
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
index 3609d5a2..397d831a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
@@ -7,9 +7,9 @@ namespace ksys::act {
 
 SEAD_SINGLETON_DISPOSER_IMPL(BaseProcCreateTaskSelector)
 
-util::Task* BaseProcCreateTaskSelector::selectTask(const util::TaskSelectionContext& context) {
-    util::Task* min_task = nullptr;
-    util::Task* lane1_task = nullptr;
+Task* BaseProcCreateTaskSelector::selectTask(const TaskSelectionContext& context) {
+    Task* min_task = nullptr;
+    Task* lane1_task = nullptr;
     auto min = std::numeric_limits<float>::max();
 
     for (auto& it : context) {
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
index 40e5da31..9c03e271 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
@@ -15,9 +15,9 @@ public:
     auto& getDelegate() { return mDelegate; }
 
 private:
-    util::Task* selectTask(const util::TaskSelectionContext& context);
+    Task* selectTask(const TaskSelectionContext& context);
 
-    util::TaskSelectionDelegateT<BaseProcCreateTaskSelector> mDelegate{
+    TaskSelectionDelegateT<BaseProcCreateTaskSelector> mDelegate{
         this, &BaseProcCreateTaskSelector::selectTask};
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateTaskSelector, 0x40);
diff --git a/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp b/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
index a83e48d0..5541b11a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
@@ -31,12 +31,12 @@ BaseProcDeleter::~BaseProcDeleter() {
 void BaseProcDeleter::init(const InitArg& arg) {
     auto* heap = arg.heap;
     mTaskQueue = arg.task_queue;
-    mTaskMgr = new (heap) util::TaskMgr(heap);
-    mTaskMgr->init<util::ManagedTask>(arg.task_queue_size, heap);
+    mTaskMgr = new (heap) TaskMgr(heap);
+    mTaskMgr->init<ManagedTask>(arg.task_queue_size, heap);
 }
 
 bool BaseProcDeleter::requestPreDelete(BaseProc* proc) {
-    util::TaskRequest request{false};
+    TaskRequest request{false};
     request.mSynchronous = false;
     request.mQueue = mTaskQueue;
     request.mDelegate = &mPreDeleteDelegate;
@@ -44,13 +44,13 @@ bool BaseProcDeleter::requestPreDelete(BaseProc* proc) {
     request.mLaneId = u8(TaskLane::PreDelete);
     request.mName = "PreDelete";
 
-    util::TaskMgrRequest req;
+    TaskMgrRequest req;
     req.request = &request;
     return mTaskMgr->trySubmitRequest(req);
 }
 
 void BaseProcDeleter::requestUnloadActorParam(ActorParam* param) {
-    util::TaskRequest request{false};
+    TaskRequest request{false};
     request.mSynchronous = false;
     request.mQueue = mTaskQueue;
     request.mDelegate = &mUnloadActorParamDelegate;
@@ -58,7 +58,7 @@ void BaseProcDeleter::requestUnloadActorParam(ActorParam* param) {
     request.mLaneId = u8(TaskLane::UnloadActorParam);
     request.mName = "UnloadActorParam";
 
-    util::TaskMgrRequest req;
+    TaskMgrRequest req;
     req.request = &request;
     mTaskMgr->submitRequest(req);
 }
diff --git a/src/KingSystem/ActorSystem/actBaseProcDeleter.h b/src/KingSystem/ActorSystem/actBaseProcDeleter.h
index a46f5131..a3575293 100644
--- a/src/KingSystem/ActorSystem/actBaseProcDeleter.h
+++ b/src/KingSystem/ActorSystem/actBaseProcDeleter.h
@@ -5,10 +5,10 @@
 #include "KingSystem/Utils/Thread/Task.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 class TaskMgr;
 class TaskQueue;
-}  // namespace ksys::util
+}  // namespace ksys
 
 namespace ksys::act {
 
@@ -19,7 +19,7 @@ class BaseProcDeleter {
 public:
     struct InitArg {
         sead::Heap* heap;
-        util::TaskQueue* task_queue;
+        TaskQueue* task_queue;
         int task_queue_size;
     };
 
@@ -40,12 +40,11 @@ private:
     bool doPreDelete(void* proc);
     bool doUnloadParam(void* actor_param);
 
-    util::TaskMgr* mTaskMgr{};
-    util::TaskQueue* mTaskQueue{};
+    TaskMgr* mTaskMgr{};
+    TaskQueue* mTaskQueue{};
     sead::Buffer<void*> mBuffer;
-    util::TaskDelegateT<BaseProcDeleter> mPreDeleteDelegate{this, &BaseProcDeleter::doPreDelete};
-    util::TaskDelegateT<BaseProcDeleter> mUnloadActorParamDelegate{this,
-                                                                   &BaseProcDeleter::doUnloadParam};
+    TaskDelegateT<BaseProcDeleter> mPreDeleteDelegate{this, &BaseProcDeleter::doPreDelete};
+    TaskDelegateT<BaseProcDeleter> mUnloadActorParamDelegate{this, &BaseProcDeleter::doUnloadParam};
 };
 KSYS_CHECK_SIZE_NX150(BaseProcDeleter, 0x68);
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcHandle.cpp b/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
index bdde1c62..cc780cc3 100644
--- a/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
@@ -26,7 +26,7 @@ bool BaseProcHandle::hasProcCreationFailed() const {
     if (status == BaseProcUnit::Status::NoProc || status == BaseProcUnit::Status::Cancelled)
         return true;
 
-    if (mUnit->getCreateTask().getStatus() == util::Task::Status::RemovedFromQueue ||
+    if (mUnit->getCreateTask().getStatus() == Task::Status::RemovedFromQueue ||
         status == BaseProcUnit::Status::Cancelled) {
         return true;
     }
@@ -38,7 +38,7 @@ bool BaseProcHandle::isProcCreationCancelled() const {
     if (!mUnit)
         return false;
 
-    if (mUnit->getCreateTask().getStatus() == util::Task::Status::RemovedFromQueue)
+    if (mUnit->getCreateTask().getStatus() == Task::Status::RemovedFromQueue)
         return true;
 
     if (mUnit->getStatus() == BaseProcUnit::Status::Cancelled)
diff --git a/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp b/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
index 2785fd5b..e927df9e 100644
--- a/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
@@ -42,8 +42,8 @@ void BaseProcInitializer::init(sead::Heap* parent_heap, const BaseProcInitialize
     mThreads.allocBufferAssert(NumThreads, mHeap);
 
     const auto init_queue = [&] {
-        mTaskQueue = new (mHeap) util::TaskQueue(mHeap);
-        util::TaskQueue::InitArg arg;
+        mTaskQueue = new (mHeap) TaskQueue(mHeap);
+        TaskQueue::InitArg arg;
         arg.enable_locks = true;
         arg.heap = mHeap;
         arg.num_lanes = 5;
@@ -53,16 +53,16 @@ void BaseProcInitializer::init(sead::Heap* parent_heap, const BaseProcInitialize
     };
     init_queue();
 
-    mTaskMgr = new (mHeap) util::TaskMgr(mHeap);
+    mTaskMgr = new (mHeap) TaskMgr(mHeap);
     mTaskMgr->initAndCheckType<BaseProcCreateTask>(args.queue_size, mHeap);
 
     for (int i = 0; i < NumThreads; ++i) {
         mThreads[i].thread_name.format("%s", args.thread_name.cstr());
-        mThreads[i].thread = new (mHeap) util::GameTaskThread(
+        mThreads[i].thread = new (mHeap) GameTaskThread(
             mThreads[i].thread_name, mHeap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(20),
             sead::MessageQueue::BlockType::Blocking, 0x7FFFFFFF, 0x100000, 64);
         {
-            util::TaskThread::InitArg arg;
+            TaskThread::InitArg arg;
             arg.num_lanes = 5;
             arg.heap = mHeap;
             arg.queue = mTaskQueue;
@@ -109,7 +109,7 @@ bool BaseProcInitializer::requestCreateBaseProc(const BaseProcCreateRequest& req
     if (req.task_data)
         task_req.mName = req.task_data->mProcName;
 
-    util::TaskMgrRequest mgr_req;
+    TaskMgrRequest mgr_req;
     if (req.task_data->mProcHandle) {
         if (!req.task_data->mProcHandle->allocUnit()) {
             req.task_data->mProcHandle->setFailed(true);
@@ -214,11 +214,11 @@ void BaseProcInitializer::pauseMainThread() {
 void BaseProcInitializer::resumeMainThread() {
     mThreads[0].valid = true;
     if (!mThreads[0].thread) {
-        mThreads[0].thread = new (mHeap) util::GameTaskThread(
+        mThreads[0].thread = new (mHeap) GameTaskThread(
             mThreads[0].thread_name, mHeap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(20),
             sead::MessageQueue::BlockType::Blocking, 0x7FFFFFFF, 0x100000, 64);
         {
-            util::TaskThread::InitArg arg;
+            TaskThread::InitArg arg;
             arg.num_lanes = 5;
             arg.heap = mHeap;
             arg.queue = mTaskQueue;
@@ -272,8 +272,8 @@ int BaseProcInitializer::getQueueSize(int x) const {
     return count;
 }
 
-void BaseProcInitializer::removeTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate) {
-    util::TaskQueueLock lock;
+void BaseProcInitializer::removeTasksIf(sead::IDelegate1R<Task*, bool>& predicate) {
+    TaskQueueLock lock;
     auto it = mTaskQueue->activeTasksRobustBegin(&lock);
     const auto end = mTaskQueue->activeTasksRobustEnd();
     for (; it != end; ++it) {
diff --git a/src/KingSystem/ActorSystem/actBaseProcInitializer.h b/src/KingSystem/ActorSystem/actBaseProcInitializer.h
index 649e0002..4c4b5900 100644
--- a/src/KingSystem/ActorSystem/actBaseProcInitializer.h
+++ b/src/KingSystem/ActorSystem/actBaseProcInitializer.h
@@ -10,11 +10,11 @@ namespace sead {
 class Heap;
 }
 
-namespace ksys::util {
+namespace ksys {
 class TaskMgr;
 class TaskQueue;
 class TaskThread;
-}  // namespace ksys::util
+}  // namespace ksys
 
 namespace ksys::act {
 
@@ -24,14 +24,14 @@ struct BaseProcCreateRequest;
 struct BaseProcInitializerArgs {
     u32 queue_size;
     sead::SafeString thread_name = "BaseProcCreate";
-    util::TaskSelectionDelegate* task_selector = nullptr;
+    TaskSelectionDelegate* task_selector = nullptr;
 };
 
 class BaseProcInitializer {
 public:
     struct ThreadInfo {
         bool valid = false;
-        util::TaskThread* thread = nullptr;
+        TaskThread* thread = nullptr;
         sead::FixedSafeString<32> thread_name;
     };
     KSYS_CHECK_SIZE_NX150(ThreadInfo, 0x48);
@@ -68,15 +68,15 @@ public:
     void cancelTasks();
     int getQueueSize(int x = -1) const;
 
-    void removeTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate);
+    void removeTasksIf(sead::IDelegate1R<Task*, bool>& predicate);
     void setActorGenerationEnabled(bool enabled);
 
-    util::TaskQueue* getTaskQueue() const { return mTaskQueue; }
+    TaskQueue* getTaskQueue() const { return mTaskQueue; }
 
 private:
     sead::Buffer<ThreadInfo> mThreads;
-    util::TaskMgr* mTaskMgr = nullptr;
-    util::TaskQueue* mTaskQueue = nullptr;
+    TaskMgr* mTaskMgr = nullptr;
+    TaskQueue* mTaskQueue = nullptr;
     sead::Heap* mHeap = nullptr;
     bool mActorGenerationEnabled = true;
 };
diff --git a/src/KingSystem/ActorSystem/actBaseProcMgr.cpp b/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
index 9c8c59be..7d9b3120 100644
--- a/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
@@ -614,7 +614,7 @@ int BaseProcMgr::getInitializerQueueSizeEx(int x) const {
     return mProcInitializer->getQueueSize(x);
 }
 
-void BaseProcMgr::removeInitializerTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate) {
+void BaseProcMgr::removeInitializerTasksIf(sead::IDelegate1R<Task*, bool>& predicate) {
     mProcInitializer->removeTasksIf(predicate);
 }
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcMgr.h b/src/KingSystem/ActorSystem/actBaseProcMgr.h
index 26c5d97c..67def589 100644
--- a/src/KingSystem/ActorSystem/actBaseProcMgr.h
+++ b/src/KingSystem/ActorSystem/actBaseProcMgr.h
@@ -37,7 +37,7 @@ class BaseProcJobQue;
 struct BaseProcCreateRequest {
     u32 task_lane_id;
     BaseProcCreateTaskData* task_data;
-    util::TaskRemoveCallback* task_remove_callback;
+    TaskRemoveCallback* task_remove_callback;
 };
 
 class BaseProcMgr {
@@ -201,7 +201,7 @@ public:
     bool isAnyInitializerThreadActive() const;
     int getInitializerQueueSize() const;
     int getInitializerQueueSizeEx(int x = -1) const;
-    void removeInitializerTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate);
+    void removeInitializerTasksIf(sead::IDelegate1R<Task*, bool>& predicate);
     void setActorGenerationEnabled(bool enabled);
 
     // endregion