diff --git a/esp32/lib/ESP32-sveltekit/TaskManager.h b/esp32/lib/ESP32-sveltekit/TaskManager.h
index a764b70..4efa8a5 100644
--- a/esp32/lib/ESP32-sveltekit/TaskManager.h
+++ b/esp32/lib/ESP32-sveltekit/TaskManager.h
@@ -6,12 +6,12 @@
 #include <vector>
 
 #define IDLE_STACK_SIZE 2048
-#define DEFAULT_STACK_SIZE 2048+512
+#define DEFAULT_STACK_SIZE 2048 + 512
 
-#define DELETE_TASK(handle) if (handle != nullptr) vTaskDelete(handle)
+#define DELETE_TASK(handle) \
+    if (handle != nullptr) vTaskDelete(handle)
 
-struct task_t
-{
+struct task_t {
     String name;
     TaskHandle_t handle;
     uint32_t stackSize;
@@ -21,8 +21,7 @@ struct task_t
     bool active; // blocked ('B'), ready ('R'), deleted ('D') or suspended ('S').
 };
 
-class IdleTask
-{
+class IdleTask {
   private:
     float _idleRatio = 0;
     unsigned long _lastMeasurement;
@@ -33,22 +32,17 @@ class IdleTask
     unsigned long counter = 0;
 
   public:
-    void ProcessIdleTime()
-    {
+    void ProcessIdleTime() {
         _lastMeasurement = millis();
         counter = 0;
 
-        for(;;)
-        {
+        for (;;) {
             int delta = millis() - _lastMeasurement;
-            if (delta >= kMillisPerCalc)
-            {
+            if (delta >= kMillisPerCalc) {
                 _idleRatio = static_cast<float>(counter) / delta;
                 _lastMeasurement = millis();
                 counter = 0;
-            }
-            else
-            {
+            } else {
                 esp_task_wdt_reset();
                 delayMicroseconds(kMillisPerLoop * 1000);
                 counter += kMillisPerLoop;
@@ -56,26 +50,18 @@ class IdleTask
         }
     }
 
-    IdleTask() : _lastMeasurement(millis())
-    {
-    }
+    IdleTask() : _lastMeasurement(millis()) {}
 
-    float GetCPUUsage() const
-    {
-        if (millis() - _lastMeasurement > kMillisPerCalc)
-            return 100.0f;
+    float GetCPUUsage() const {
+        if (millis() - _lastMeasurement > kMillisPerCalc) return 100.0f;
 
         return 100.0f - 100 * _idleRatio;
     }
 
-    static void IdleTaskEntry(void *that)
-    {
-        static_cast<IdleTask *>(that)->ProcessIdleTime();
-    }
+    static void IdleTaskEntry(void *that) { static_cast<IdleTask *>(that)->ProcessIdleTime(); }
 };
 
-class TaskManager
-{
+class TaskManager {
   private:
     std::map<const char *, task_t> _tasks;
     IdleTask _taskIdle0;
@@ -85,95 +71,75 @@ class TaskManager
     TaskHandle_t _hIdle1;
 
   public:
-    TaskManager()
-    {
-    }
+    TaskManager() {}
 
-    void begin()
-    {
-        createTask(IdleTask::IdleTaskEntry, "Idle Core 0", IDLE_STACK_SIZE, &_taskIdle0, tskIDLE_PRIORITY-1, &_hIdle0, 0); 
-        createTask(IdleTask::IdleTaskEntry, "Idle Core 1", IDLE_STACK_SIZE, &_taskIdle1, tskIDLE_PRIORITY-1, &_hIdle1, 1);
+    void begin() {
+        createTask(IdleTask::IdleTaskEntry, "Idle Core 0", IDLE_STACK_SIZE, &_taskIdle0, tskIDLE_PRIORITY - 1, &_hIdle0,
+                   0);
+        createTask(IdleTask::IdleTaskEntry, "Idle Core 1", IDLE_STACK_SIZE, &_taskIdle1, tskIDLE_PRIORITY - 1, &_hIdle1,
+                   1);
         esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(0));
         esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(1));
         esp_task_wdt_add(_hIdle0);
         esp_task_wdt_add(_hIdle1);
     }
 
-    std::vector<task_t> getTasks()
-    {
+    std::vector<task_t> getTasks() {
         std::vector<task_t> tasks;
-        for (auto const &task : _tasks)
-            tasks.push_back(task.second);
+        for (auto const &task : _tasks) tasks.push_back(task.second);
         return tasks;
     }
 
-    int getTaskCount() const
-    {
-        return _tasks.size();
-    }
+    int getTaskCount() const { return _tasks.size(); }
 
-    int getKernelTaskCount() const
-    {
-        return uxTaskGetNumberOfTasks();
-    }
+    int getKernelTaskCount() const { return uxTaskGetNumberOfTasks(); }
 
-    void update()
-    {
-        for (auto const &task : _tasks)
-        {
+    void update() {
+        for (auto const &task : _tasks) {
             _tasks[task.first].priority = uxTaskPriorityGet(task.second.handle);
             _tasks[task.first].coreId = xTaskGetAffinity(task.second.handle);
         }
     }
 
-    float getCpuUsage(int iCore = -1) const
-    {
-        if (iCore == 0) return _taskIdle0.GetCPUUsage();
-        else if (iCore == 1) return _taskIdle1.GetCPUUsage();
+    float getCpuUsage(int iCore = -1) const {
+        if (iCore == 0)
+            return _taskIdle0.GetCPUUsage();
+        else if (iCore == 1)
+            return _taskIdle1.GetCPUUsage();
         return (_taskIdle0.GetCPUUsage() + _taskIdle1.GetCPUUsage()) / 2;
     }
 
-    BaseType_t createTask(void (*taskFunction)(void *), const char * name, uint32_t stackSize = 2048,
-                          void *params = nullptr, UBaseType_t priority = tskIDLE_PRIORITY + 1, TaskHandle_t* handle = nullptr,
-                          BaseType_t coreId = -1)
-    {
-        BaseType_t res = coreId == -1 
-            ? xTaskCreate(taskFunction, name, stackSize, params, priority + 1, handle)
-            : xTaskCreatePinnedToCore(taskFunction, name, stackSize, params, priority + 1, handle, coreId);
+    BaseType_t createTask(void (*taskFunction)(void *), const char *name, uint32_t stackSize = 2048,
+                          void *params = nullptr, UBaseType_t priority = tskIDLE_PRIORITY + 1,
+                          TaskHandle_t *handle = nullptr, BaseType_t coreId = -1) {
+        BaseType_t res =
+            coreId == -1 ? xTaskCreate(taskFunction, name, stackSize, params, priority + 1, handle)
+                         : xTaskCreatePinnedToCore(taskFunction, name, stackSize, params, priority + 1, handle, coreId);
         task_t task = {name, handle, stackSize, priority + 1, coreId, coreId != -1, true};
-        if (res == pdPASS)
-            _tasks[name] = task;
+        if (res == pdPASS) _tasks[name] = task;
         return res;
     }
 
-    void suspendTask(const char * name)
-    {
-        if (_tasks.find(name) != _tasks.end())
-        {
+    void suspendTask(const char *name) {
+        if (_tasks.find(name) != _tasks.end()) {
             vTaskSuspend(_tasks[name].handle);
             _tasks[name].active = false;
         }
     }
 
-    void resumeTask(const char * name)
-    {
-        if (_tasks.find(name) != _tasks.end())
-        {
+    void resumeTask(const char *name) {
+        if (_tasks.find(name) != _tasks.end()) {
             vTaskResume(_tasks[name].handle);
             _tasks[name].active = true;
         }
     }
 
-    void notifyTask(const char * name, uint32_t notificationValue, eNotifyAction action = eSetValueWithOverwrite)
-    {
-        if (_tasks.find(name) != _tasks.end())
-            xTaskNotify(_tasks[name].handle, notificationValue, action);
+    void notifyTask(const char *name, uint32_t notificationValue, eNotifyAction action = eSetValueWithOverwrite) {
+        if (_tasks.find(name) != _tasks.end()) xTaskNotify(_tasks[name].handle, notificationValue, action);
     }
 
-    void deleteTask(const char * name)
-    {
-        if (_tasks.find(name) != _tasks.end())
-        {
+    void deleteTask(const char *name) {
+        if (_tasks.find(name) != _tasks.end()) {
             vTaskDelete(_tasks[name].handle);
             _tasks.erase(name);
         }