refactor(websocket): remove RuntimeExecutor and standardize on threadpool executor

unify execution model across websocket (App, Server, Session)
migrate all examples to executor factory
improve lifecycle consistency with core

Author: GaspardKirira

examples/advanced/src/server.cpp

@@ -11,10 +11,10 @@
  *  Vix.cpp
  *
  * This example demonstrates a fully featured, production-style WebSocket
- * server using the Vix.cpp runtime. It showcases how to combine:
+ * server using the Vix.cpp executor abstraction. It showcases how to combine:
  *
  *  • Asynchronous native WebSocket server
- *  • RuntimeExecutor integration
+ *  • Thread pool executor integration
  *  • Room-based messaging (join, leave, broadcast)
  *  • Typed JSON protocol ("type" + "payload")
  *  • Persistent message storage using SQLite (WAL enabled)
@@ -37,7 +37,7 @@
 
 #include <vix.hpp>
 
-#include <vix/executor/RuntimeExecutor.hpp>
+#include <vix/experimental/ThreadPoolExecutor.hpp>
 #include <vix/websocket.hpp>
 #include <vix/websocket/LongPolling.hpp>
 #include <vix/websocket/LongPollingBridge.hpp>
@@ -57,9 +57,13 @@ int main()
 
   using njson = nlohmann::json;
 
-  auto exec = std::make_shared<vix::executor::RuntimeExecutor>();
+  auto exec = vix::experimental::make_threadpool_executor(
+      4, // min threads
+      8, // max threads
+      0  // default priority
+  );
 
-  App wsApp{"config/config.json", exec};
+  App wsApp{"config/config.json", std::move(exec)};
   auto &ws = wsApp.server();
 
   WebSocketMetrics metrics;

examples/chat_room.cpp

@@ -44,7 +44,7 @@
 //
 
 #include <vix/config/Config.hpp>
-#include <vix/executor/RuntimeExecutor.hpp>
+#include <vix/experimental/ThreadPoolExecutor.hpp>
 #include <vix/websocket.hpp>
 
 int main()
@@ -54,11 +54,15 @@ int main()
   // 1) Load config
   vix::config::Config cfg{"config/config.json"};
 
-  // 2) Runtime executor for async WebSocket processing
-  auto exec = std::make_shared<vix::executor::RuntimeExecutor>();
+  // 2) Thread pool executor for async WebSocket processing
+  auto exec = vix::experimental::make_threadpool_executor(
+      4, // min threads
+      8, // max threads
+      0  // default priority
+  );
 
   // 3) Construct the WebSocket server
-  Server ws(cfg, exec);
+  Server ws(cfg, std::move(exec));
 
   // 4) On new connection
   ws.on_open(

examples/simple/src/app_example.cpp

@@ -11,9 +11,8 @@
  *  Vix.cpp
  */
 #include <iostream>
-#include <memory>
 
-#include <vix/executor/RuntimeExecutor.hpp>
+#include <vix/experimental/ThreadPoolExecutor.hpp>
 #include <vix/websocket.hpp>
 
 using vix::websocket::App;
@@ -40,9 +39,13 @@ void handle_chat(
 
 int main()
 {
-  auto exec = std::make_shared<vix::executor::RuntimeExecutor>();
+  auto exec = vix::experimental::make_threadpool_executor(
+      4, // min threads
+      8, // max threads
+      0  // default priority
+  );
 
-  App app{"config/config.json", exec};
+  App app{"config/config.json", std::move(exec)};
 
   (void)app.ws("/chat", handle_chat);
 

examples/simple/src/minimal_ws_server.cpp

@@ -11,21 +11,24 @@
  *  Vix.cpp
  */
 #include <iostream>
-#include <memory>
 #include <string>
 
 #include <vix/config/Config.hpp>
-#include <vix/executor/RuntimeExecutor.hpp>
+#include <vix/experimental/ThreadPoolExecutor.hpp>
 #include <vix/websocket.hpp>
 #include <vix/websocket/protocol.hpp>
 
 namespace ws = vix::websocket;
 
 int main()
 {
-  auto exec = std::make_shared<vix::executor::RuntimeExecutor>();
+  auto exec = vix::experimental::make_threadpool_executor(
+      4, // min threads
+      8, // max threads
+      0  // default priority
+  );
 
-  ws::App app{"config/config.json", exec};
+  ws::App app{"config/config.json", std::move(exec)};
   auto &server = app.server();
 
   std::cout << "[minimal] WebSocket server starting on port "

examples/simple/src/simple_client.cpp

@@ -9,59 +9,60 @@
  *  that can be found in the License file.
  *
  *  Vix.cpp
- * @brief Minimal WebSocket client example for Vix.cpp
+ *  @brief Minimal WebSocket client example for Vix.cpp
  *
- * This example demonstrates the simplest possible interactive WebSocket
- * client built with the Vix.cpp WebSocket module. It connects to a server,
- * listens for typed JSON messages, prints structured chat output, and allows
- * the user to send messages through a basic terminal prompt.
+ *  This example demonstrates the simplest possible interactive WebSocket
+ *  client built with the Vix.cpp WebSocket module. It connects to a server,
+ *  listens for typed JSON messages, prints structured chat output, and allows
+ *  the user to send messages through a basic terminal prompt.
  *
- * Core Features Demonstrated
- * ---------------------------
- * 1. Client Creation:
- *      The example creates a WebSocket client targeting localhost:9090 and
- *      automatically manages connection state through Vix.cpp abstractions.
+ *  Core Features Demonstrated
+ *  ---------------------------
+ *  1. Client Creation:
+ *       The example creates a WebSocket client targeting localhost:9090 and
+ *       automatically manages connection state through Vix.cpp abstractions.
  *
- * 2. Typed JSON Protocol Handling:
- *      Incoming frames are parsed using JsonMessage and routed based on their
- *      "type":
- *          • chat.system  – server/system events
- *          • chat.message – regular chat messages
- *          • fallback     – prints raw JSON
+ *  2. Typed JSON Protocol Handling:
+ *       Incoming frames are parsed using JsonMessage and routed based on their
+ *       "type":
+ *           • chat.system  - server/system events
+ *           • chat.message - regular chat messages
+ *           • fallback     - prints raw JSON
  *
- * 3. Auto-Reconnect:
- *      The client will automatically attempt to reconnect every 3 seconds
- *      if the connection is lost.
+ *  3. Auto-Reconnect:
+ *       The client will automatically attempt to reconnect every 3 seconds
+ *       if the connection is lost.
  *
- * 4. Heartbeat / Keep-Alive:
- *      A periodic ping is enabled to keep NAT/proxy connections alive.
+ *  4. Heartbeat / Keep-Alive:
+ *       A periodic ping is enabled to keep NAT/proxy connections alive.
  *
- * 5. Interactive Input Loop:
- *      The user enters a pseudonym and can then type messages in real time.
- *      Typing "/quit" closes the session gracefully.
+ *  5. Interactive Input Loop:
+ *       The user enters a pseudonym and can then type messages in real time.
+ *       Typing "/quit" closes the session gracefully.
  *
- * Intended Usage
- * --------------
- * This minimal client is ideal for:
- *  • Testing or debugging a Vix.cpp WebSocket server
- *  • Learning how to work with the JSON protocol
- *  • Building simple chat tools or monitoring utilities
- *  • Demonstrating the basics of WebSocket event handling in C++
+ *  Intended Usage
+ *  --------------
+ *  This minimal client is ideal for:
+ *   - Testing or debugging a Vix.cpp WebSocket server
+ *   - Learning how to work with the JSON protocol
+ *   - Building simple chat tools or monitoring utilities
+ *   - Demonstrating the basics of WebSocket event handling in C++
  *
- * How to Run
- * ----------
- * 1. Start a Vix WebSocket server (see simple_server.cpp).
- * 2. Build this example:
- *        cmake -S . -B build && cmake --build build -j
- * 3. Run the client:
- *        ./build/examples/simple/simple_client
- * 4. Type messages interactively, or use "/quit" to exit.
+ *  How to Run
+ *  ----------
+ *  1. Start a Vix WebSocket server (see simple_server.cpp).
+ *  2. Build this example:
+ *         cmake -S . -B build && cmake --build build -j
+ *  3. Run the client:
+ *         ./build/examples/simple/simple_client
+ *  4. Type messages interactively, or use "/quit" to exit.
  *
- * This is a deliberately minimal example—see the advanced client example for
- * support for rooms, reconnection logic, structured system events, and
- * persistent message workflows.
+ *  This is a deliberately minimal example. See the advanced client example for
+ *  support for rooms, reconnection logic, structured system events, and
+ *  persistent message workflows.
  */
 
+#include <chrono>
 #include <iostream>
 #include <string>
 
@@ -75,64 +76,80 @@ int main()
 
   auto client = Client::create("localhost", "9090", "/");
 
-  client->on_open([]
-                  { std::cout << "[client] Connected ✅" << std::endl; });
+  client->on_open(
+      []
+      {
+        std::cout << "[client] Connected ✅" << std::endl;
+      });
 
-  client->on_message([](const std::string &msg)
-                     {
+  client->on_message(
+      [](const std::string &msg)
+      {
         auto jm = JsonMessage::parse(msg);
 
         if (!jm)
         {
-            std::cout << msg << std::endl;
-            return;
+          std::cout << msg << std::endl;
+          return;
         }
 
         const std::string &type = jm->type;
 
         if (type == "chat.system")
         {
-            std::cout << "[system] " << jm->get_string("text") << std::endl;
+          std::cout << "[system] " << jm->get_string("text") << std::endl;
         }
         else if (type == "chat.message")
         {
-            std::string user = jm->get_string("user");
-            if (user.empty())
-                user = "anonymous";
-
-            std::cout << "[chat] " << user
-                      << ": " << jm->get_string("text") << std::endl;
+          std::string user = jm->get_string("user");
+          if (user.empty())
+          {
+            user = "anonymous";
+          }
+
+          std::cout << "[chat] " << user
+                    << ": " << jm->get_string("text") << std::endl;
         }
         else
         {
-            std::cout << msg << std::endl;
-        } });
+          std::cout << msg << std::endl;
+        }
+      });
 
-  client->on_close([]
-                   { std::cout << "[client] Disconnected." << std::endl; });
+  client->on_close(
+      []
+      {
+        std::cout << "[client] Disconnected." << std::endl;
+      });
 
-  client->on_error([](const std::string &error)
-                   { std::cerr << "[client] error: " << error << std::endl; });
+  client->on_error(
+      [](const std::string &error)
+      {
+        std::cerr << "[client] error: " << error << std::endl;
+      });
 
   client->enable_auto_reconnect(true, std::chrono::seconds(3));
   client->enable_heartbeat(std::chrono::seconds(20));
 
   client->connect();
 
-  // Prompt username
   std::cout << "Pseudo: ";
   std::string user;
   std::getline(std::cin, user);
+
   if (user.empty())
+  {
     user = "anonymous";
+  }
 
   std::cout << "Type messages, /quit to exit\n";
 
-  // Message loop
   for (std::string line; std::getline(std::cin, line);)
   {
     if (line == "/quit")
+    {
       break;
+    }
 
     client->send(
         "chat.message",

examples/simple/src/simple_server.cpp

@@ -16,7 +16,7 @@
  * simplest reference implementation, showing only the essential components:
  *
  *  • Loading configuration (port, timeouts, etc.)
- *  • Creating a RuntimeExecutor for async execution
+ *  • Creating a thread pool executor for async execution
  *  • Starting a WebSocket server instance
  *  • Reacting to connection events (on_open)
  *  • Handling typed JSON messages (on_typed_message)
@@ -28,9 +28,9 @@
  *      The WebSocket server automatically binds to the port defined in
  *      config/config.json and manages all asynchronous I/O.
  *
- * 2. Runtime Integration:
- *      The example uses Vix’s RuntimeExecutor to drive async execution,
- *      aligning the WebSocket layer with the modern Vix runtime architecture.
+ * 2. Executor Integration:
+ *      The example uses a thread pool executor to drive async execution,
+ *      aligning the WebSocket layer with the Vix executor abstraction.
  *
  * 3. Global Broadcast:
  *      Messages received with type "chat.message" are broadcast to all
@@ -67,10 +67,8 @@
  * persistence, metrics, room routing, history replay, and auto-reconnect.
  */
 
-#include <memory>
-
 #include <vix/config/Config.hpp>
-#include <vix/executor/RuntimeExecutor.hpp>
+#include <vix/experimental/ThreadPoolExecutor.hpp>
 #include <vix/websocket.hpp>
 
 int main()
@@ -80,10 +78,14 @@ int main()
   // Load configuration from config/config.json
   vix::config::Config cfg{"config/config.json"};
 
-  // Runtime executor for async work
-  auto exec = std::make_shared<vix::executor::RuntimeExecutor>();
+  // Thread pool executor for async work
+  auto exec = vix::experimental::make_threadpool_executor(
+      4, // min threads
+      8, // max threads
+      0  // default priority
+  );
 
-  Server ws(cfg, exec);
+  Server ws(cfg, std::move(exec));
 
   // On new connection: broadcast a welcome system message
   ws.on_open(