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)

12 files changed, 72 insertions, 78 deletions

diff --git a/src/KingSystem/Resource/resArchiveWork.cpp b/src/KingSystem/Resource/resArchiveWork.cpp
index 0838b7ec..e537faaf 100644
--- a/src/KingSystem/Resource/resArchiveWork.cpp
+++ b/src/KingSystem/Resource/resArchiveWork.cpp
@@ -16,7 +16,7 @@ ArchiveWork::~ArchiveWork() {
 }
 
 bool ArchiveWork::init(const ArchiveWork::InitArg& arg) {
-    mEvent = new (arg.heap) util::Event(
+    mEvent = new (arg.heap) Event(
         nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, false);
     mEvent->resetSignal();
 
diff --git a/src/KingSystem/Resource/resArchiveWork.h b/src/KingSystem/Resource/resArchiveWork.h
index 2ec0f3e2..5229f551 100644
--- a/src/KingSystem/Resource/resArchiveWork.h
+++ b/src/KingSystem/Resource/resArchiveWork.h
@@ -12,9 +12,7 @@ namespace ksys {
 
 class OverlayArena;
 
-namespace util {
 class Event;
-}
 
 namespace res {
 
@@ -41,7 +39,7 @@ public:
     void setEvent();
 
 private:
-    util::Event* mEvent = nullptr;
+    Event* mEvent = nullptr;
     OverlayArena* mArena = nullptr;
 };
 KSYS_CHECK_SIZE_NX150(ArchiveWork, 0x10);
diff --git a/src/KingSystem/Resource/resControlTask.cpp b/src/KingSystem/Resource/resControlTask.cpp
index 3cee95c5..66c3470e 100644
--- a/src/KingSystem/Resource/resControlTask.cpp
+++ b/src/KingSystem/Resource/resControlTask.cpp
@@ -3,11 +3,11 @@
 
 namespace ksys::res {
 
-ControlTask::ControlTask(sead::Heap* heap) : util::ManagedTask(heap) {}
+ControlTask::ControlTask(sead::Heap* heap) : ManagedTask(heap) {}
 
 void ControlTask::onRun_() {}
 
-void ControlTask::prepareImpl_(util::TaskRequest* req_) {
+void ControlTask::prepareImpl_(TaskRequest* req_) {
     auto* req = static_cast<ControlTaskRequest*>(req_);
 
     mData.mHasResLoadReq = req->mHasResLoadReq;
diff --git a/src/KingSystem/Resource/resControlTask.h b/src/KingSystem/Resource/resControlTask.h
index 13a68ecc..2ceebc78 100644
--- a/src/KingSystem/Resource/resControlTask.h
+++ b/src/KingSystem/Resource/resControlTask.h
@@ -12,8 +12,8 @@ namespace ksys::res {
 class Handle;
 class ResourceUnit;
 
-class ControlTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(ControlTaskData, util::TaskData)
+class ControlTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(ControlTaskData, TaskData)
 public:
     virtual ~ControlTaskData() = default;
 
@@ -25,22 +25,22 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(ControlTaskData, 0x138);
 
-class ControlTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(ControlTask, util::ManagedTask)
+class ControlTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(ControlTask, ManagedTask)
 public:
     explicit ControlTask(sead::Heap* heap);
 
 private:
     void onRun_() override;
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
     void preRemoveImpl_() override;
 
     ControlTaskData mData;
 };
 KSYS_CHECK_SIZE_NX150(ControlTask, 0x1f8);
 
-class ControlTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(ControlTaskRequest, util::TaskRequest)
+class ControlTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(ControlTaskRequest, TaskRequest)
 public:
     explicit ControlTaskRequest(bool has_handle = false) : TaskRequest(has_handle) {}
 
diff --git a/src/KingSystem/Resource/resHandle.cpp b/src/KingSystem/Resource/resHandle.cpp
index c620ee25..c2d5d83e 100644
--- a/src/KingSystem/Resource/resHandle.cpp
+++ b/src/KingSystem/Resource/resHandle.cpp
@@ -209,7 +209,7 @@ bool Handle::parseResource(Context* context) {
     if (mFlags.isOn(Flag::UnloadRequested))
         return false;
 
-    if (mTaskHandle.getStatus() == util::ManagedTaskHandle::Status::TaskRemoved ||
+    if (mTaskHandle.getStatus() == ManagedTaskHandle::Status::TaskRemoved ||
         (mUnit && mUnit->isTask1NotQueued())) {
         stubbedLogFunction();
         mStatus = Status::Cancelled;
diff --git a/src/KingSystem/Resource/resHandle.h b/src/KingSystem/Resource/resHandle.h
index aacad690..538a53f4 100644
--- a/src/KingSystem/Resource/resHandle.h
+++ b/src/KingSystem/Resource/resHandle.h
@@ -111,7 +111,7 @@ private:
     sead::TypedBitFlag<Flag> mFlags = Flag::Dummy;
     Status mStatus = Status::NoFile;
     ResourceUnit* mUnit = nullptr;
-    util::ManagedTaskHandle mTaskHandle;
+    ManagedTaskHandle mTaskHandle;
     sead::ListNode mListNode;
 };
 KSYS_CHECK_SIZE_NX150(Handle, 0x50);
diff --git a/src/KingSystem/Resource/resMemoryTask.cpp b/src/KingSystem/Resource/resMemoryTask.cpp
index 3f580852..17a78d94 100644
--- a/src/KingSystem/Resource/resMemoryTask.cpp
+++ b/src/KingSystem/Resource/resMemoryTask.cpp
@@ -3,11 +3,11 @@
 
 namespace ksys::res {
 
-MemoryTask::MemoryTask(sead::Heap* heap) : util::ManagedTask(heap) {}
+MemoryTask::MemoryTask(sead::Heap* heap) : ManagedTask(heap) {}
 
 void MemoryTask::onRun_() {}
 
-void MemoryTask::prepareImpl_(util::TaskRequest* req_) {
+void MemoryTask::prepareImpl_(TaskRequest* req_) {
     auto* req = static_cast<MemoryTaskRequest*>(req_);
     mData._8 = req->mData_8;
     mData._c = req->mData_c;
diff --git a/src/KingSystem/Resource/resMemoryTask.h b/src/KingSystem/Resource/resMemoryTask.h
index 2de1a5f8..f7d3b416 100644
--- a/src/KingSystem/Resource/resMemoryTask.h
+++ b/src/KingSystem/Resource/resMemoryTask.h
@@ -7,8 +7,8 @@
 
 namespace ksys::res {
 
-class MemoryTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(MemoryTaskData, util::TaskData)
+class MemoryTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(MemoryTaskData, TaskData)
 public:
     virtual ~MemoryTaskData() = default;
 
@@ -18,25 +18,25 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(MemoryTaskData, 0xa8);
 
-class MemoryTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(MemoryTask, util::ManagedTask)
+class MemoryTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(MemoryTask, ManagedTask)
 public:
     explicit MemoryTask(sead::Heap* heap);
     ~MemoryTask() override { ; }
 
 private:
     void onRun_() override;
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
     void preRemoveImpl_() override;
 
-    void setUserData() { util::ManagedTask::setUserData(&mData); }
+    void setUserData() { ManagedTask::setUserData(&mData); }
 
     MemoryTaskData mData;
 };
 KSYS_CHECK_SIZE_NX150(MemoryTask, 0x168);
 
-class MemoryTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(MemoryTaskRequest, util::TaskRequest)
+class MemoryTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(MemoryTaskRequest, TaskRequest)
 public:
     MemoryTaskRequest() = default;
 
diff --git a/src/KingSystem/Resource/resResourceMgrTask.cpp b/src/KingSystem/Resource/resResourceMgrTask.cpp
index 74e845a1..f241361f 100644
--- a/src/KingSystem/Resource/resResourceMgrTask.cpp
+++ b/src/KingSystem/Resource/resResourceMgrTask.cpp
@@ -23,8 +23,8 @@
 namespace ksys::res {
 
 namespace {
-class ClearCachesTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(ClearCachesTaskData, util::TaskData)
+class ClearCachesTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(ClearCachesTaskData, TaskData)
 public:
     virtual ~ClearCachesTaskData() = default;
 
@@ -106,17 +106,17 @@ void ResourceMgrTask::insertOverlayArena(OverlayArena* arena) {
     }
 }
 
-util::TaskThread* ResourceMgrTask::makeResourceLoadingThread(sead::Heap* heap,
-                                                             bool use_game_task_thread) {
+TaskThread* ResourceMgrTask::makeResourceLoadingThread(sead::Heap* heap,
+                                                       bool use_game_task_thread) {
     if (use_game_task_thread) {
-        return new (heap) util::GameTaskThread(
+        return new (heap) GameTaskThread(
             "Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
             sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xfa000, 32);
     }
 
-    return new (heap) util::TaskThread(
-        "Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
-        sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xa000, 32);
+    return new (heap)
+        TaskThread("Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
+                   sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xa000, 32);
 }
 
 void ResourceMgrTask::clearAllCaches(OverlayArena* arena) {
@@ -135,13 +135,13 @@ void ResourceMgrTask::clearAllCaches(OverlayArena* arena) {
     req.mData_c = -1;
     req.mData_mStr = arena->getHeap()->getName();
 
-    util::TaskMgrRequest task_mgr_request;
+    TaskMgrRequest task_mgr_request;
     task_mgr_request.request = &req;
     mResourceMemoryTaskMgr->submitRequest(task_mgr_request);
 }
 
 bool ResourceMgrTask::isDefragDone() const {
-    return mTask2->getStatus() == util::Task::Status::PostFinishCallback;
+    return mTask2->getStatus() == Task::Status::PostFinishCallback;
 }
 
 f32 ResourceMgrTask::getDefragProgress() const {
@@ -263,7 +263,7 @@ void ResourceMgrTask::deregisterUnit(ResourceUnit* unit) {
     }
 }
 
-void ResourceMgrTask::requestClearCache(ResourceUnit** p_unit, util::Task* task) {
+void ResourceMgrTask::requestClearCache(ResourceUnit** p_unit, Task* task) {
     if (!p_unit || !*p_unit || !(*p_unit)->isStatusFlag8000Set()) {
         stubbedLogFunction();
         return;
@@ -405,7 +405,7 @@ bool ResourceMgrTask::calc_(void*) {
         req.mData_8 = false;
         req.mData_c = -1;
 
-        util::TaskMgrRequest request;
+        TaskMgrRequest request;
         request.request = &req;
         mResourceMemoryTaskMgr->submitRequest(request);
         mTexHandleMgr->clearAllCache();
@@ -522,7 +522,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
     auto* unit = mUnitPool.tryAlloc();
 
     if (!unit) {
-        util::TaskQueueLock lock;
+        TaskQueueLock lock;
 
         auto* queue = mResourceControlThread->getTaskQueue();
         auto it = queue->activeTasksRobustBegin(&lock);
@@ -541,7 +541,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
         ClearCachesTaskData data;
         data._8 = true;
         data._c = 100;
-        util::TaskRequest req;
+        TaskRequest req;
         req.mLaneId = u8(LaneId::_8);
         req.mHasHandle = true;
         req.mSynchronous = true;
@@ -555,7 +555,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
     }
 
     if (!unit) {
-        util::TaskQueueLock lock;
+        TaskQueueLock lock;
 
         auto* queue = mResourceControlThread->getTaskQueue();
         auto it = queue->activeTasksRobustBegin(&lock);
@@ -658,7 +658,7 @@ void ResourceMgrTask::clearUnits_() {
 
 void ResourceMgrTask::systemCalc_() {
     if (mTask1->canSubmitRequest()) {
-        util::TaskRequest request;
+        TaskRequest request;
         request.mSynchronous = false;
         request.mHasHandle = false;
         request.mLaneId = u8(LaneId::_6);
@@ -732,7 +732,7 @@ void ResourceMgrTask::clearAllCachesSynchronously(OverlayArena* arena) {
     req.mData_c = -1;
     req.mData_mStr = arena->getHeap()->getName();
 
-    util::TaskMgrRequest task_mgr_request;
+    TaskMgrRequest task_mgr_request;
     task_mgr_request.request = &req;
     mResourceMemoryTaskMgr->submitRequest(task_mgr_request);
 }
diff --git a/src/KingSystem/Resource/resResourceMgrTask.h b/src/KingSystem/Resource/resResourceMgrTask.h
index eddcf08b..6cec9e1b 100644
--- a/src/KingSystem/Resource/resResourceMgrTask.h
+++ b/src/KingSystem/Resource/resResourceMgrTask.h
@@ -35,11 +35,9 @@ class SZSDecompressor;
 namespace ksys {
 class OverlayArena;
 
-namespace util {
 class TaskMgr;
 class TaskPostRunResult;
 class TaskThread;
-}  // namespace util
 }  // namespace ksys
 
 namespace ksys::res {
@@ -99,8 +97,7 @@ public:
     };
 
     using ResourceUnitDelegate = sead::Delegate1RFunc<void*, bool>;
-    using TaskCallback =
-        sead::Delegate2Func<util::TaskPostRunResult*, const util::TaskPostRunContext&>;
+    using TaskCallback = sead::Delegate2Func<TaskPostRunResult*, const TaskPostRunContext&>;
     using MemoryTaskDelegate = sead::Delegate1R<ResourceMgrTask, void*, bool>;
 
     struct ResourceUnitDelegatePair {
@@ -114,7 +111,7 @@ public:
 
     void insertOverlayArena(OverlayArena* arena);
 
-    util::TaskThread* makeResourceLoadingThread(sead::Heap* heap, bool use_game_task_thread);
+    TaskThread* makeResourceLoadingThread(sead::Heap* heap, bool use_game_task_thread);
 
     void clearAllCaches(OverlayArena* arena);
     OverlayArena* getTexHandleMgrArena() const;
@@ -157,7 +154,7 @@ public:
     void registerUnit(ResourceUnit* unit);
     void deregisterUnit(ResourceUnit* unit);
 
-    void requestClearCache(ResourceUnit** p_unit, util::Task* task = nullptr);
+    void requestClearCache(ResourceUnit** p_unit, Task* task = nullptr);
     void requestClearCacheForSync(ResourceUnit** p_unit, bool clear_immediately,
                                   bool delete_immediately);
 
@@ -206,7 +203,7 @@ public:
     ResourceUnit* clearCachesAndGetUnit(const GetUnitArg& arg);
 
     struct SetActorCreateInitializerThreadsArg {
-        sead::PtrArray<util::TaskThread>* threads;
+        sead::PtrArray<TaskThread>* threads;
     };
     void setActorCreateInitializerThreads(const SetActorCreateInitializerThreadsArg& arg);
     void clearActorCreateInitializerThreads();
@@ -261,10 +258,10 @@ public:
 
     void removeOverlayArena(OverlayArena* arena);
 
-    util::TaskThread* getResourceLoadingThread() const { return mResourceLoadingThread; }
-    util::TaskThread* getResourceControlThread() const { return mResourceControlThread; }
-    util::TaskThread* getResourceMemoryThread() const { return mResourceMemoryThread; }
-    util::TaskThread* getMovableMemoryThread() const { return mMovableMemoryThread; }
+    TaskThread* getResourceLoadingThread() const { return mResourceLoadingThread; }
+    TaskThread* getResourceControlThread() const { return mResourceControlThread; }
+    TaskThread* getResourceMemoryThread() const { return mResourceMemoryThread; }
+    TaskThread* getMovableMemoryThread() const { return mMovableMemoryThread; }
 
     ResourceUnitDelegatePair& getUnitInitLoadFn() { return mUnitInitLoadFn; }
     auto& getUnitAdjustHeapFn() { return mUnitAdjustHeapFn; }
@@ -315,17 +312,17 @@ private:
     sead::TypedBitFlag<CacheControlFlag> mCacheControlFlags;
     u32 _17c = 0;
     sead::Heap* mResSystemHeap = nullptr;
-    util::TaskThread* mResourceLoadingThread = nullptr;
-    util::TaskThread* mResourceControlThread = nullptr;
-    util::TaskThread* mResourceMemoryThread = nullptr;
-    util::TaskThread* mMovableMemoryThread = nullptr;
-    sead::PtrArray<util::TaskThread>* mActorCreateInitializerThreads = nullptr;
-    util::TaskMgr* mResourceControlTaskMgr = nullptr;
-    util::TaskMgr* mResourceMemoryTaskMgr;
+    TaskThread* mResourceLoadingThread = nullptr;
+    TaskThread* mResourceControlThread = nullptr;
+    TaskThread* mResourceMemoryThread = nullptr;
+    TaskThread* mMovableMemoryThread = nullptr;
+    sead::PtrArray<TaskThread>* mActorCreateInitializerThreads = nullptr;
+    TaskMgr* mResourceControlTaskMgr = nullptr;
+    TaskMgr* mResourceMemoryTaskMgr;
     ControlTask* mControlTask = nullptr;
-    util::Task* mTask1 = nullptr;
-    util::Task* mTask2 = nullptr;
-    util::Task* mTask3 = nullptr;
+    Task* mTask1 = nullptr;
+    Task* mTask2 = nullptr;
+    Task* mTask3 = nullptr;
 
     EntryFactoryBase* mEntryFactoryBase = nullptr;
     EntryFactoryBase* mDefaultEntryFactory = nullptr;
@@ -349,9 +346,8 @@ private:
     MemoryTaskDelegate mDefragAllMemoryMgrFn;
 
     MemoryTaskDelegate mLoadFn;
-    sead::Delegate2<ResourceMgrTask, util::TaskPostRunResult*, const util::TaskPostRunContext&>
-        mLoadCb;
-    sead::Delegate1<ResourceMgrTask, const util::TaskRemoveCallbackContext&> mLoadTaskRemoveCb;
+    sead::Delegate2<ResourceMgrTask, TaskPostRunResult*, const TaskPostRunContext&> mLoadCb;
+    sead::Delegate1<ResourceMgrTask, const TaskRemoveCallbackContext&> mLoadTaskRemoveCb;
 
     MemoryTaskDelegate mCalcFn;
     MemoryTaskDelegate mCalcArenaHeapSizeFn;
@@ -413,7 +409,7 @@ private:
     u8 _9c0d98 = 1;
     size_t _9c0da0 = 500;
 
-    util::Task mTask;                     // TODO: rename
+    Task mTask;                           // TODO: rename
     sead::CriticalSection mCritSection4;  // TODO: rename
     sead::TickTime mTickTime;
     MemoryTaskDelegate mSystemCalcFn;
diff --git a/src/KingSystem/Resource/resUnit.cpp b/src/KingSystem/Resource/resUnit.cpp
index 186cffb2..2aa93005 100644
--- a/src/KingSystem/Resource/resUnit.cpp
+++ b/src/KingSystem/Resource/resUnit.cpp
@@ -98,12 +98,12 @@ bool ResourceUnit::init(const ResourceUnit::InitArg& arg) {
     }
 
     {
-        util::TaskDelegateSetter setter;
+        TaskDelegateSetter setter;
         mTask1.setDelegate(setter);
     }
 
     {
-        util::TaskDelegateSetter setter;
+        TaskDelegateSetter setter;
         mTask2.setDelegate(setter);
     }
 
@@ -154,7 +154,7 @@ void ResourceUnit::updateStatus() {
 }
 
 bool ResourceUnit::isTask1NotQueued() const {
-    return mTask1.getStatus() == util::Task::Status::RemovedFromQueue;
+    return mTask1.getStatus() == Task::Status::RemovedFromQueue;
 }
 
 bool ResourceUnit::isStatus0() const {
@@ -243,7 +243,7 @@ bool ResourceUnit::removeTask3FromQueue() {
 void ResourceUnit::requestInitLoad(const RequestInitLoadArg& arg) {
     mStatus = Status::_7;
 
-    util::TaskRequest req;
+    TaskRequest req;
     req.mHasHandle = arg.has_handle;
     req.mSynchronous = false;
     req.mLaneId = arg.lane_id;
diff --git a/src/KingSystem/Resource/resUnit.h b/src/KingSystem/Resource/resUnit.h
index 981b7678..87a8f565 100644
--- a/src/KingSystem/Resource/resUnit.h
+++ b/src/KingSystem/Resource/resUnit.h
@@ -196,14 +196,14 @@ private:
 
     void initLoad(void* x = nullptr);
     void prepareLoad();
-    void requestPrepareLoad(util::TaskPostRunResult* result, const util::TaskPostRunContext& ctx);
+    void requestPrepareLoad(TaskPostRunResult* result, const TaskPostRunContext& ctx);
 
     void unloadForSync();
     void clearCacheForSync(bool x);
 
     void unload();
     void clearCache(void* x);
-    void requestClearCache(util::TaskPostRunResult* result, const util::TaskPostRunContext& ctx);
+    void requestClearCache(TaskPostRunResult* result, const TaskPostRunContext& ctx);
 
     sead::TypedBitFlag<CacheFlag> mCacheFlags;
     sead::TypedBitFlag<Flag> mFlags;
@@ -226,13 +226,13 @@ private:
     sead::ListNode mArenaUnitListNode;
     sead::ListNode mArenaUnitListNode2;
     sead::ListNode mResMgrUnitListNode;
-    util::Task mTask1;
-    util::Task mTask2;
-    util::Task mTask3;
+    Task mTask1;
+    Task mTask2;
+    Task mTask3;
     ResourceUnitMapNode mMapNode{this};
     sead::Atomic<s32> mCounter;
-    util::Event mEvent{nullptr,
-                       sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, true};
+    Event mEvent{nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified,
+                 true};
     sead::ResourceMgr::LoadArg mLoadArg;
     sead::FixedSafeString<128> mPath;
     sead::Heap* mHeap = nullptr;